*** This log is abridged to its last 500 KB:

me:fname)
                            op:assign_op.Equal
                            rhs:(w <Lit_Chars _comp_complete_known_hosts>)
                          )
                        ]
                      )
                    ]
                    right:<Op_DSemi ";;">
                  )
                ]
                arms_end:<KW_Esac esac>
              )
              (C (w <Lit_Chars unset>) (w <Lit_Chars -f>) (w (DQ ($ FUNCNAME))))
              (C
                (w <Lit_Chars complete>)
                (w <Lit_Chars -F>)
                (w ($ fname))
                (w <Lit_Chars vncviewer>)
              )
              (C (w ($ fname)) (w (DQ ($ VSub_At))))
            ]
            right:<Lit_RBrace "}">
          )
          code_str:"_comp_cmd_vncviewer__bootstrap()\n{\n    local fname REPLY\n    _comp_realcommand vncviewer\n    case $REPLY in\n        *xvnc4viewer) fname=_comp_cmd_xvnc4viewer ;;\n        *tightvncviewer) fname=_comp_cmd_tightvncviewer ;;\n        *) fname=_comp_complete_known_hosts ;;\n    esac\n\n    # Install real completion for subsequent completions\n    unset -f \"$FUNCNAME\"\n    complete -F $fname vncviewer\n    $fname \"$@\" # Generate completions once for now\n}"
        )
        (C
          (w <Lit_Chars complete>)
          (w <Lit_Chars -F>)
          (w <Lit_Chars _comp_cmd_vncviewer__bootstrap>)
          (w <Lit_Chars vncviewer>)
        )
      ]
      ops:[<Op_DAmp "&&">]
    )
    (command.AndOr
      children:[
        (ShFunction
          name_tok:<Lit_Chars _comp_cmd_tightvncviewer>
          name:_comp_cmd_tightvncviewer
          body:(BraceGroup
            left:<Lit_LBrace "{">
            children:[
              (C
                (w <Lit_Chars local>)
                (w <Lit_Chars cur>)
                (w <Lit_Chars prev>)
                (w <Lit_Chars words>)
                (w <Lit_Chars cword>)
                (w <Lit_Chars comp_args>)
              )
              (command.AndOr
                children:[
                  (C
                    (w <Lit_Chars _comp_initialize>)
                    (w <Lit_Chars -->)
                    (w (DQ ($ VSub_At)))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                ops:[<Op_DPipe "||">]
              )
              (command.Case
                case_kw:<KW_Case case>
                to_match:(case_arg.Word w:(w ($ prev)))
                arms_start:<KW_In in>
                arms:[
                  (CaseArm
                    left:<Lit_Chars -passwd>
                    pattern:(pat.Words words:[(w <Lit_Chars -passwd>)])
                    middle:<Right_CasePat ")">
                    action:[
                      (C (w <Lit_Chars _comp_compgen_filedir>))
                      (command.ControlFlow keyword:<ControlFlow_Return return>)
                    ]
                    right:<Op_DSemi ";;">
                  )
                  (CaseArm
                    left:<Lit_Chars -encodings>
                    pattern:(pat.Words words:[(w <Lit_Chars -encodings>)])
                    middle:<Right_CasePat ")">
                    action:[
                      (C
                        (w <Lit_Chars _comp_compgen>)
                        (w <Lit_Chars -->)
                        (w <Lit_Chars -W>)
                        (w (SQ "copyrect tight hextile zlib corre rre raw"))
                      )
                      (command.ControlFlow keyword:<ControlFlow_Return return>)
                    ]
                    right:<Op_DSemi ";;">
                  )
                  (CaseArm
                    left:<Lit_Chars -via>
                    pattern:(pat.Words words:[(w <Lit_Chars -via>)])
                    middle:<Right_CasePat ")">
                    action:[
                      (C
                        (w <Lit_Chars _comp_compgen_known_hosts>)
                        (w <Lit_Chars -->)
                        (w (DQ ($ cur)))
                      )
                      (command.ControlFlow keyword:<ControlFlow_Return return>)
                    ]
                    right:<Op_DSemi ";;">
                  )
                ]
                arms_end:<KW_Esac esac>
              )
              (command.If
                if_kw:<KW_If if>
                arms:[
                  (IfArm
                    keyword:...0x1f12
                    cond:[
                      (command.Sentence
                        child:(command.DBracket
                          left:<KW_DLeftBracket "[[">
                          expr:(bool_expr.Binary
                            op_id:BoolBinary_GlobDEqual
                            left:(w ($ cur))
                            right:(w <Lit_Chars -> <Lit_Other "*">)
                          )
                          right:<Lit_DRightBracket "]]">
                        )
                        terminator:<Op_Semi ";">
                      )
                    ]
                    then_kw:<KW_Then then>
                    action:[
                      (C
                        (w <Lit_Chars _comp_compgen>)
                        (w <Lit_Chars -->)
                        (w <Lit_Chars -W>)
                        (w
                          (SQ
                            "-help -listen -via -shared -noshared -viewonly\n            -fullscreen -noraiseonbeep -passwd -encodings -bgr233 -owncmap\n            -truecolour -truecolor -depth -compresslevel -quality -nojpeg\n            -nocursorshape -x11cursor"
                          )
                        )
                      )
                    ]
                    then_tok:...0x1ea6
                  )
                ]
                else_kw:<KW_Else else>
                else_action:[
                  (C
                    (w <Lit_Chars _comp_compgen_known_hosts>)
                    (w <Lit_Chars -->)
                    (w (DQ ($ cur)))
                  )
                ]
                fi_kw:<KW_Fi fi>
              )
            ]
            right:<Lit_RBrace "}">
          )
          code_str:"_comp_cmd_tightvncviewer()\n{\n    local cur prev words cword comp_args\n    _comp_initialize -- \"$@\" || return\n\n    case $prev in\n        -passwd)\n            _comp_compgen_filedir\n            return\n            ;;\n        -encodings)\n            _comp_compgen -- -W 'copyrect tight hextile zlib corre rre raw'\n            return\n            ;;\n        -via)\n            _comp_compgen_known_hosts -- \"$cur\"\n            return\n            ;;\n    esac\n\n    if [[ $cur == -* ]]; then\n        _comp_compgen -- -W '-help -listen -via -shared -noshared -viewonly\n            -fullscreen -noraiseonbeep -passwd -encodings -bgr233 -owncmap\n            -truecolour -truecolor -depth -compresslevel -quality -nojpeg\n            -nocursorshape -x11cursor'\n    else\n        _comp_compgen_known_hosts -- \"$cur\"\n    fi\n}"
        )
        (C
          (w <Lit_Chars complete>)
          (w <Lit_Chars -F>)
          (w <Lit_Chars _comp_cmd_tightvncviewer>)
          (w <Lit_Chars tightvncviewer>)
        )
      ]
      ops:[<Op_DAmp "&&">]
    )
    (command.AndOr
      children:[
        (ShFunction
          name_tok:<Lit_Chars _comp_cmd_xvnc4viewer>
          name:_comp_cmd_xvnc4viewer
          body:(BraceGroup
            left:<Lit_LBrace "{">
            children:[
              (C
                (w <Lit_Chars local>)
                (w <Lit_Chars cur>)
                (w <Lit_Chars prev>)
                (w <Lit_Chars words>)
                (w <Lit_Chars cword>)
                (w <Lit_Chars comp_args>)
              )
              (command.AndOr
                children:[
                  (C
                    (w <Lit_Chars _comp_initialize>)
                    (w <Lit_Chars -->)
                    (w (DQ ($ VSub_At)))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                ops:[<Op_DPipe "||">]
              )
              (C
                (w <Lit_Chars local>)
                (w
                  <Lit_VarLike "opt=">
                  (BracedVarSub
                    left:<Left_DollarBrace "${">
                    name_tok:<VSub_Name prev>
                    var_name:prev
                    suffix_op:(suffix_op.PatSub
                      pat:(w <Lit_Chars -->)
                      replace:(w <Lit_Chars ->)
                      replace_mode:Lit_Pound
                      slash_tok:<VOp2_Slash />
                    )
                    right:<Right_DollarBrace "}">
                  )
                )
              )
              (command.Case
                case_kw:<KW_Case case>
                to_match:(case_arg.Word
                  w:(w
                    (BracedVarSub
                      left:<Left_DollarBrace "${">
                      name_tok:<VSub_Name opt>
                      var_name:opt
                      suffix_op:(suffix_op.Unary
                        op:<VOp1_DComma ",,">
                        arg_word:(w)
                      )
                      right:<Right_DollarBrace "}">
                    )
                  )
                )
                arms_start:<KW_In in>
                arms:[
                  (CaseArm
                    left:<Lit_Chars -passwd>
                    pattern:(pat.Words
                      words:[
                        (w <Lit_Chars -passwd>)
                        (w <Lit_Chars -passwordfile>)
                      ]
                    )
                    middle:<Right_CasePat ")">
                    action:[
                      (C (w <Lit_Chars _comp_compgen_filedir>))
                      (command.ControlFlow keyword:<ControlFlow_Return return>)
                    ]
                    right:<Op_DSemi ";;">
                  )
                  (CaseArm
                    left:<Lit_Chars -preferredencoding>
                    pattern:(pat.Words
                      words:[(w <Lit_Chars -preferredencoding>)]
                    )
                    middle:<Right_CasePat ")">
                    action:[
                      (C
                        (w <Lit_Chars _comp_compgen>)
                        (w <Lit_Chars -->)
                        (w <Lit_Chars -W>)
                        (w (SQ "zrle hextile raw"))
                      )
                      (command.ControlFlow keyword:<ControlFlow_Return return>)
                    ]
                    right:<Op_DSemi ";;">
                  )
                  (CaseArm
                    left:<Lit_Chars -via>
                    pattern:(pat.Words words:[(w <Lit_Chars -via>)])
                    middle:<Right_CasePat ")">
                    action:[
                      (C
                        (w <Lit_Chars _comp_compgen_known_hosts>)
                        (w <Lit_Chars -->)
                        (w (DQ ($ cur)))
                      )
                      (command.ControlFlow keyword:<ControlFlow_Return return>)
                    ]
                    right:<Op_DSemi ";;">
                  )
                ]
                arms_end:<KW_Esac esac>
              )
              (command.If
                if_kw:<KW_If if>
                arms:[
                  (IfArm
                    keyword:...0x22a6
                    cond:[
                      (command.Sentence
                        child:(command.DBracket
                          left:<KW_DLeftBracket "[[">
                          expr:(bool_expr.LogicalOr
                            left:(bool_expr.Binary
                              op_id:BoolBinary_GlobDEqual
                              left:(w ($ cur))
                              right:(w <Lit_Chars -> <Lit_Other "*">)
                            )
                            right:(bool_expr.Binary
                              op_id:BoolBinary_GlobDEqual
                              left:(w ($ cur))
                              right:(w <Lit_Chars --> <Lit_Other "*">)
                            )
                          )
                          right:<Lit_DRightBracket "]]">
                        )
                        terminator:<Op_Semi ";">
                      )
                    ]
                    then_kw:<KW_Then then>
                    action:[
                      (C
                        (w <Lit_Chars local>)
                        (w <Lit_Chars dash>)
                        (w
                          <Lit_VarLike "options=">
                          (word_part.InitializerLiteral
                            left:<Op_LParen "(">
                            pairs:[
                              (InitializerWord.ArrayWord
                                w:(w <Lit_Chars AcceptClipboard>)
                              )
                              (InitializerWord.ArrayWord
                                w:(w <Lit_Chars AutoSelect>)
                              )
                              (InitializerWord.ArrayWord
                                w:(w <Lit_Chars DebugDelay>)
                              )
                              (InitializerWord.ArrayWord
                                w:(w <Lit_Chars display>)
                              )
                              (InitializerWord.ArrayWord
                                w:(w <Lit_Chars DotWhenNoCursor>)
                              )
                              (InitializerWord.ArrayWord
                                w:(w <Lit_Chars FullColor>)
                              )
                              (InitializerWord.ArrayWord
                                w:(w <Lit_Chars FullColour>)
                              )
                              (InitializerWord.ArrayWord
                                w:(w <Lit_Chars FullScreen>)
                              )
                              (InitializerWord.ArrayWord
                                w:(w <Lit_Chars geometry>)
                              )
                              (InitializerWord.ArrayWord w:(w <Lit_Chars help>))
                              (InitializerWord.ArrayWord
                                w:(w <Lit_Chars listen>)
                              )
                              (InitializerWord.ArrayWord w:(w <Lit_Chars Log>))
                              (InitializerWord.ArrayWord
                                w:(w <Lit_Chars LowColourLevel>)
                              )
                              (InitializerWord.ArrayWord
                                w:(w <Lit_Chars MenuKey>)
                              )
                              (InitializerWord.ArrayWord w:(w <Lit_Chars name>))
                              (InitializerWord.ArrayWord
                                w:(w <Lit_Chars Parent>)
                              )
                              (InitializerWord.ArrayWord
                                w:(w <Lit_Chars passwd>)
                              )
                              (InitializerWord.ArrayWord
                                w:(w <Lit_Chars PasswordFile>)
                              )
                              (InitializerWord.ArrayWord
                                w:(w <Lit_Chars PointerEventInterval>)
                              )
                              (InitializerWord.ArrayWord
                                w:(w <Lit_Chars PreferredEncoding>)
                              )
                              (InitializerWord.ArrayWord
                                w:(w <Lit_Chars SendClipboard>)
                              )
                              (InitializerWord.ArrayWord
                                w:(w <Lit_Chars SendPrimary>)
                              )
                              (InitializerWord.ArrayWord
                                w:(w <Lit_Chars Shared>)
                              )
                              (InitializerWord.ArrayWord
                                w:(w <Lit_Chars UseLocalCursor>)
                              )
                              (InitializerWord.ArrayWord w:(w <Lit_Chars via>))
                              (InitializerWord.ArrayWord
                                w:(w <Lit_Chars ViewOnly>)
                              )
                              (InitializerWord.ArrayWord
                                w:(w <Lit_Chars WMDecorationHeight>)
                              )
                              (InitializerWord.ArrayWord
                                w:(w <Lit_Chars WMDecorationWidth>)
                              )
                              (InitializerWord.ArrayWord
                                w:(w <Lit_Chars ZlibLevel>)
                              )
                            ]
                            right:<Right_Initializer ")">
                          )
                        )
                      )
                      (command.AndOr
                        children:[
                          (command.DBracket
                            left:<KW_DLeftBracket "[[">
                            expr:(bool_expr.Binary
                              op_id:BoolBinary_GlobDEqual
                              left:(w ($ cur))
                              right:(w <Lit_Chars --> <Lit_Other "*">)
                            )
                            right:<Lit_DRightBracket "]]">
                          )
                          (command.ShAssignment
                            left:<Lit_VarLike "dash=">
                            pairs:[
                              (AssignPair
                                left:...0x2a36
                                lhs:(sh_lhs.Name left:...0x2a36 name:dash)
                                op:assign_op.Equal
                                rhs:(w <Lit_Chars -->)
                              )
                            ]
                          )
                          (command.ShAssignment
                            left:<Lit_VarLike "dash=">
                            pairs:[
                              (AssignPair
                                left:...0x29fe
                                lhs:(sh_lhs.Name left:...0x29fe name:dash)
                                op:assign_op.Equal
                                rhs:(w <Lit_Chars ->)
                              )
                            ]
                          )
                        ]
                        ops:[<Op_DAmp "&&"> <Op_DPipe "||">]
                      )
                      (C
                        (w <Lit_Chars _comp_split>)
                        (w <Lit_Chars COMPREPLY>)
                        (w
                          (DQ
                            (CommandSub
                              left_token:<Left_DollarParen "$(">
                              child:(command.CommandList
                                children:[
                                  (C
                                    (w <Lit_Chars shopt>)
                                    (w <Lit_Chars -s>)
                                    (w <Lit_Chars nocasematch>)
                                  )
                                  (C
                                    (w <Lit_Chars local>)
                                    (w <Lit_Chars option>)
                                  )
                                  (command.ForEach
                                    keyword:<KW_For for>
                                    iter_names:[option]
                                    iterable:(for_iter.Words
                                      words:[
                                        (w
                                          (DQ
                                            (BracedVarSub
                                              left:<Left_DollarBrace "${">
                                              name_tok:<VSub_Name options>
                                              var_name:options
                                              bracket_op:(bracket_op.WholeArray
                                                op_id:Lit_At
                                              )
                                              right:<Right_DollarBrace "}">
                                            )
                                          )
                                        )
                                      ]
                                    )
                                    semi_tok:<Op_Semi ";">
                                    body:(command.DoGroup
                                      left:<KW_Do do>
                                      children:[
                                        (command.AndOr
                                          children:[
                                            (command.DBracket
                                              left:<KW_DLeftBracket "[[">
                                              expr:(bool_expr.Binary
                                                op_id:BoolBinary_GlobDEqual
                                                left:(w ($ dash) ($ option))
                                                right:(w
                                                  (DQ ($ cur))
                                                  <Lit_Other "*">
                                                )
                                              )
                                              right:<Lit_DRightBracket "]]">
                                            )
                                            (C
                                              (w <Lit_Chars printf>)
                                              (w (SQ "%s\\n"))
                                              (w (DQ ($ dash) ($ option)))
                                            )
                                          ]
                                          ops:[<Op_DAmp "&&">]
                                        )
                                      ]
                                      right:<KW_Done done>
                                    )
                                  )
                                ]
                              )
                              right:<Eof_RParen ")">
                            )
                          )
                        )
                      )
                    ]
                    then_tok:...0x2206
                  )
                ]
                else_kw:<KW_Else else>
                else_action:[
                  (C
                    (w <Lit_Chars _comp_compgen_known_hosts>)
                    (w <Lit_Chars -->)
                    (w (DQ ($ cur)))
                  )
                ]
                fi_kw:<KW_Fi fi>
              )
            ]
            right:<Lit_RBrace "}">
          )
          code_str:"_comp_cmd_xvnc4viewer()\n{\n    local cur prev words cword comp_args\n    _comp_initialize -- \"$@\" || return\n\n    # Both single dash (-) and double dash (--) are allowed as option prefix\n    local opt=${prev/#--/-}\n    case ${opt,,} in\n        # -passwd, -PasswordFile\n        -passwd | -passwordfile)\n            _comp_compgen_filedir\n            return\n            ;;\n        -preferredencoding)\n            _comp_compgen -- -W 'zrle hextile raw'\n            return\n            ;;\n        -via)\n            _comp_compgen_known_hosts -- \"$cur\"\n            return\n            ;;\n    esac\n\n    if [[ $cur == -* || $cur == --* ]]; then\n        # Default to vncviewer camelcase options, see `vncviewer -help'\n        local dash options=(AcceptClipboard AutoSelect DebugDelay display\n            DotWhenNoCursor FullColor FullColour FullScreen geometry help\n            listen Log LowColourLevel MenuKey name Parent passwd PasswordFile\n            PointerEventInterval PreferredEncoding SendClipboard SendPrimary\n            Shared UseLocalCursor via ViewOnly WMDecorationHeight\n            WMDecorationWidth ZlibLevel)\n        [[ $cur == --* ]] && dash=-- || dash=-\n\n        _comp_split COMPREPLY \"$(\n            shopt -s nocasematch\n            local option\n            for option in \"${options[@]}\"; do\n                [[ $dash$option == \"$cur\"* ]] && printf '%s\\n' \"$dash$option\"\n            done\n        )\"\n    else\n        _comp_compgen_known_hosts -- \"$cur\"\n    fi\n}"
        )
        (C
          (w <Lit_Chars complete>)
          (w <Lit_Chars -F>)
          (w <Lit_Chars _comp_cmd_xvnc4viewer>)
          (w <Lit_Chars xvnc4viewer>)
        )
      ]
      ops:[<Op_DAmp "&&">]
    )
  ]
)
(command.AndOr
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_vpnc>
      name:_comp_cmd_vpnc
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars cur>)
            (w <Lit_Chars prev>)
            (w <Lit_Chars words>)
            (w <Lit_Chars cword>)
            (w <Lit_Chars comp_args>)
          )
          (command.AndOr
            children:[
              (C
                (w <Lit_Chars _comp_initialize>)
                (w <Lit_Chars -->)
                (w (DQ ($ VSub_At)))
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DPipe "||">]
          )
          (command.Case
            case_kw:<KW_Case case>
            to_match:(case_arg.Word w:(w ($ prev)))
            arms_start:<KW_In in>
            arms:[
              (CaseArm
                left:<Lit_Chars --help>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --help>)
                    (w <Lit_Chars --long-help>)
                    (w <Lit_Chars --version>)
                    (w <Lit_Chars --id>)
                    (w <Lit_Chars --username>)
                    (w <Lit_Chars --domain>)
                    (w <Lit_Chars --ifname>)
                    (w <Lit_Chars --application-version>)
                    (w <Lit_Chars --local-addr>)
                    (w <Lit_Chars --local-port>)
                    (w <Lit_Chars --udp-port>)
                    (w <Lit_Chars --dpd-idle>)
                    (w <Lit_Chars --target-network>)
                    (w <Lit_Chars --ifmtu>)
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --gateway>
                pattern:(pat.Words words:[(w <Lit_Chars --gateway>)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen_known_hosts>)
                    (w <Lit_Chars -->)
                    (w (DQ ($ cur)))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --vendor>
                pattern:(pat.Words words:[(w <Lit_Chars --vendor>)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ "cisco netscreen"))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --natt-mode>
                pattern:(pat.Words words:[(w <Lit_Chars --natt-mode>)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ "natt none force-natt cisco-udp"))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --script>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --script>)
                    (w <Lit_Chars --pid-file>)
                    (w <Lit_Chars --ca-file>)
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (C (w <Lit_Chars _comp_compgen_filedir>))
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --dh>
                pattern:(pat.Words words:[(w <Lit_Chars --dh>)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ "dh1 dh2 dh5"))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --pfs>
                pattern:(pat.Words words:[(w <Lit_Chars --pfs>)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ "nopfs dh1 dh2 dh5 server"))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --ifmode>
                pattern:(pat.Words words:[(w <Lit_Chars --ifmode>)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ "tun tap"))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --debug>
                pattern:(pat.Words words:[(w <Lit_Chars --debug>)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ "0 1 2 3 99"))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --auth-mode>
                pattern:(pat.Words words:[(w <Lit_Chars --auth-mode>)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ "psk cert hybrid"))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --ca-dir>
                pattern:(pat.Words words:[(w <Lit_Chars --ca-dir>)])
                middle:<Right_CasePat ")">
                action:[
                  (C (w <Lit_Chars _comp_compgen_filedir>) (w <Lit_Chars -d>))
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --password-helper>
                pattern:(pat.Words words:[(w <Lit_Chars --password-helper>)])
                middle:<Right_CasePat ")">
                action:[
                  (C (w <Lit_Chars _comp_compgen_commands>))
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
            ]
            arms_end:<KW_Esac esac>
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x1af6
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.Binary
                        op_id:BoolBinary_GlobDEqual
                        left:(w ($ cur))
                        right:(w <Lit_Chars -> <Lit_Other "*">)
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen_help>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars --long-help>)
                  )
                ]
                then_tok:...0x2532
              )
              (IfArm
                keyword:<KW_Elif elif>
                cond:[
                  (command.Sentence
                    child:(C
                      (w <Lit_Chars _comp_looks_like_path>)
                      (w (DQ ($ cur)))
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (C (w <Lit_Chars _comp_compgen_filedir>) (w <Lit_Chars conf>))
                ]
                then_tok:...0x245a
              )
            ]
            else_kw:<KW_Else else>
            else_action:[
              (C
                (w <Lit_Chars local>)
                (w <Lit_Chars -a>)
                (w <Lit_Chars configs>)
              )
              (command.If
                if_kw:<KW_If if>
                arms:[
                  (IfArm
                    keyword:...0x235e
                    cond:[
                      (command.Sentence
                        child:(C
                          (w <Lit_Chars _comp_expand_glob>)
                          (w <Lit_Chars configs>)
                          (w (SQ "/etc/vpnc/*.conf"))
                        )
                        terminator:<Op_Semi ";">
                      )
                    ]
                    then_kw:<KW_Then then>
                    action:[
                      (command.ShAssignment
                        left:<Lit_VarLike "configs=">
                        pairs:[
                          (AssignPair
                            left:...0x22c2
                            lhs:(sh_lhs.Name left:...0x22c2 name:configs)
                            op:assign_op.Equal
                            rhs:(w
                              (word_part.InitializerLiteral
                                left:<Op_LParen "(">
                                pairs:[
                                  (InitializerWord.ArrayWord
                                    w:(w
                                      (DQ
                                        (BracedVarSub
                                          left:<Left_DollarBrace "${">
                                          name_tok:<VSub_Name configs>
                                          var_name:configs
                                          bracket_op:(bracket_op.WholeArray
                                            op_id:Lit_At
                                          )
                                          suffix_op:(suffix_op.Unary
                                            op:<VOp1_DPound "##">
                                            arg_word:(w
                                              <Lit_Other "*">
                                              <Lit_Slash />
                                            )
                                          )
                                          right:<Right_DollarBrace "}">
                                        )
                                      )
                                    )
                                  )
                                ]
                                right:<Right_Initializer ")">
                              )
                            )
                          )
                        ]
                      )
                      (command.ShAssignment
                        left:<Lit_VarLike "configs=">
                        pairs:[
                          (AssignPair
                            left:...0x2236
                            lhs:(sh_lhs.Name left:...0x2236 name:configs)
                            op:assign_op.Equal
                            rhs:(w
                              (word_part.InitializerLiteral
                                left:<Op_LParen "(">
                                pairs:[
                                  (InitializerWord.ArrayWord
                                    w:(w
                                      (DQ
                                        (BracedVarSub
                                          left:<Left_DollarBrace "${">
                                          name_tok:<VSub_Name configs>
                                          var_name:configs
                                          bracket_op:(bracket_op.WholeArray
                                            op_id:Lit_At
                                          )
                                          suffix_op:(suffix_op.Unary
                                            op:<VOp1_Percent "%">
                                            arg_word:(w <Lit_Chars .conf>)
                                          )
                                          right:<Right_DollarBrace "}">
                                        )
                                      )
                                    )
                                  )
                                ]
                                right:<Right_Initializer ")">
                              )
                            )
                          )
                        ]
                      )
                      (C
                        (w <Lit_Chars compopt>)
                        (w <Lit_Chars -o>)
                        (w <Lit_Chars filenames>)
                      )
                      (C
                        (w <Lit_Chars _comp_compgen>)
                        (w <Lit_Chars -->)
                        (w <Lit_Chars -W>)
                        (w (SQ "\"${configs[@]}\""))
                      )
                    ]
                    then_tok:...0x22de
                  )
                ]
                else_action:[]
                fi_kw:<KW_Fi fi>
              )
            ]
            fi_kw:<KW_Fi fi>
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_vpnc()\n{\n    local cur prev words cword comp_args\n    _comp_initialize -- \"$@\" || return\n\n    case $prev in\n        --help | --long-help | --version | --id | --username | --domain | \\\n            --ifname | --application-version | --local-addr | --local-port | \\\n            --udp-port | --dpd-idle | --target-network | --ifmtu)\n            return\n            ;;\n        --gateway)\n            _comp_compgen_known_hosts -- \"$cur\"\n            return\n            ;;\n        --vendor)\n            _comp_compgen -- -W 'cisco netscreen'\n            return\n            ;;\n        --natt-mode)\n            _comp_compgen -- -W 'natt none force-natt cisco-udp'\n            return\n            ;;\n        --script | --pid-file | --ca-file)\n            _comp_compgen_filedir\n            return\n            ;;\n        --dh)\n            _comp_compgen -- -W 'dh1 dh2 dh5'\n            return\n            ;;\n        --pfs)\n            _comp_compgen -- -W 'nopfs dh1 dh2 dh5 server'\n            return\n            ;;\n        --ifmode)\n            _comp_compgen -- -W 'tun tap'\n            return\n            ;;\n        --debug)\n            _comp_compgen -- -W '0 1 2 3 99'\n            return\n            ;;\n        --auth-mode)\n            _comp_compgen -- -W 'psk cert hybrid'\n            return\n            ;;\n        --ca-dir)\n            _comp_compgen_filedir -d\n            return\n            ;;\n        --password-helper)\n            _comp_compgen_commands\n            return\n            ;;\n    esac\n\n    if [[ $cur == -* ]]; then\n        _comp_compgen_help -- --long-help\n    elif _comp_looks_like_path \"$cur\"; then\n        # explicit filename\n        _comp_compgen_filedir conf\n    else\n        # config name, /etc/vpnc/<name>.conf\n        local -a configs\n        if _comp_expand_glob configs '/etc/vpnc/*.conf'; then\n            configs=(\"${configs[@]##*/}\")\n            configs=(\"${configs[@]%.conf}\")\n            compopt -o filenames\n            _comp_compgen -- -W '\"${configs[@]}\"'\n        fi\n    fi\n}"
    )
    (C
      (w <Lit_Chars complete>)
      (w <Lit_Chars -F>)
      (w <Lit_Chars _comp_cmd_vpnc>)
      (w <Lit_Chars vpnc>)
    )
  ]
  ops:[<Op_DAmp "&&">]
)
(C
  (w <Lit_Chars eval>)
  (w <Lit_Chars -->)
  (w
    (DQ
      (CommandSub
        left_token:<Left_DollarParen "$(">
        child:(C
          (w (DQ ($ 1)))
          (w <Lit_Chars gen-completions>)
          (w <Lit_Chars bash>)
        )
        right:<Eof_RParen ")">
      )
    )
  )
)
  [[ $OSTYPE == *@(linux|darwin)* ]] || return 1
                 ^~
./watch:3: Extended glob won't work without FNM_EXTMATCH support in libc
(command.AndOr
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_webmitm>
      name:_comp_cmd_webmitm
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars cur>)
            (w <Lit_Chars prev>)
            (w <Lit_Chars words>)
            (w <Lit_Chars cword>)
            (w <Lit_Chars comp_args>)
          )
          (command.AndOr
            children:[
              (C
                (w <Lit_Chars _comp_initialize>)
                (w <Lit_Chars -->)
                (w (DQ ($ VSub_At)))
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DPipe "||">]
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x109a
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.Binary
                        op_id:BoolBinary_GlobDEqual
                        left:(w ($ cur))
                        right:(w <Lit_Chars -> <Lit_Other "*">)
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[(C (w <Lit_Chars _comp_compgen_usage>))]
                then_tok:...0x102e
              )
            ]
            else_kw:<KW_Else else>
            else_action:[
              (C
                (w <Lit_Chars _comp_compgen_known_hosts>)
                (w <Lit_Chars -->)
                (w (DQ ($ cur)))
              )
            ]
            fi_kw:<KW_Fi fi>
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_webmitm()\n{\n    local cur prev words cword comp_args\n    _comp_initialize -- \"$@\" || return\n\n    if [[ $cur == -* ]]; then\n        _comp_compgen_usage\n    else\n        _comp_compgen_known_hosts -- \"$cur\"\n    fi\n\n}"
    )
    (C
      (w <Lit_Chars complete>)
      (w <Lit_Chars -F>)
      (w <Lit_Chars _comp_cmd_webmitm>)
      (w <Lit_Chars webmitm>)
    )
  ]
  ops:[<Op_DAmp "&&">]
)
(command.AndOr
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_wget>
      name:_comp_cmd_wget
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars cur>)
            (w <Lit_Chars prev>)
            (w <Lit_Chars words>)
            (w <Lit_Chars cword>)
            (w <Lit_Chars was_split>)
            (w <Lit_Chars comp_args>)
          )
          (command.AndOr
            children:[
              (C
                (w <Lit_Chars _comp_initialize>)
                (w <Lit_Chars -s>)
                (w <Lit_Chars -->)
                (w (DQ ($ VSub_At)))
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DPipe "||">]
          )
          (C
            (w <Lit_Chars local>)
            (w <Lit_VarLike "noargopts="> (SQ "!(-*|*[DPoaOitTwlQeBUARIX]*)"))
          )
          (command.Case
            case_kw:<KW_Case case>
            to_match:(case_arg.Word w:(w ($ prev)))
            arms_start:<KW_In in>
            arms:[
              (CaseArm
                left:<Lit_Chars --version>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --version>)
                    (w <Lit_Chars --help>)
                    (w
                      <Lit_Chars ->
                      (${ VSub_Name noargopts)
                      <Lit_LBracket "[">
                      <Lit_Chars hV>
                      <Lit_RBracket "]">
                    )
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --progress>
                pattern:(pat.Words words:[(w <Lit_Chars --progress>)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ "bar dot"))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --bind-address>
                pattern:(pat.Words words:[(w <Lit_Chars --bind-address>)])
                middle:<Right_CasePat ")">
                action:[
                  (C (w <Lit_Chars _comp_compgen_ip_addresses>))
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --domains>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --domains>)
                    (w <Lit_Chars --exclude-domains>)
                    (w <Lit_Chars -> (${ VSub_Name noargopts) <Lit_Chars D>)
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen_known_hosts>)
                    (w <Lit_Chars -->)
                    (w (DQ ($ cur)))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --restrict-file-names>
                pattern:(pat.Words
                  words:[(w <Lit_Chars --restrict-file-names>)]
                )
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars local>)
                    (w
                      <Lit_VarLike "excludes=">
                      (word_part.InitializerLiteral
                        left:<Op_LParen "(">
                        pairs:[]
                        right:<Right_Initializer ")">
                      )
                    )
                  )
                  (command.Case
                    case_kw:<KW_Case case>
                    to_match:(case_arg.Word w:(w ($ cur)))
                    arms_start:<KW_In in>
                    arms:[
                      (CaseArm
                        left:<Lit_Star "*">
                        pattern:(pat.Words
                          words:[
                            (w <Lit_Star "*"> <Lit_Chars unix> <Lit_Star "*">)
                            (w
                              <Lit_Star "*">
                              <Lit_Chars windows>
                              <Lit_Star "*">
                            )
                          ]
                        )
                        middle:<Right_CasePat ")">
                        action:[
                          (command.ShAssignment
                            left:<Lit_VarLike "excludes=">
                            pairs:[
                              (AssignPair
                                left:...0x1676
                                lhs:(sh_lhs.Name left:...0x1676 name:excludes)
                                op:assign_op.Equal
                                rhs:(w
                                  (word_part.InitializerLiteral
                                    left:<Op_LParen "(">
                                    pairs:[
                                      (InitializerWord.ArrayWord
                                        w:(w <Lit_Chars windows>)
                                      )
                                      (InitializerWord.ArrayWord
                                        w:(w <Lit_Chars unix>)
                                      )
                                    ]
                                    right:<Right_Initializer ")">
                                  )
                                )
                              )
                            ]
                          )
                        ]
                        right:<Op_DSemiAmp ";;&">
                      )
                      (CaseArm
                        left:<Lit_Star "*">
                        pattern:(pat.Words
                          words:[
                            (w
                              <Lit_Star "*">
                              <Lit_Chars lowercase>
                              <Lit_Star "*">
                            )
                            (w
                              <Lit_Star "*">
                              <Lit_Chars uppercase>
                              <Lit_Star "*">
                            )
                          ]
                        )
                        middle:<Right_CasePat ")">
                        action:[
                          (command.ShAssignment
                            left:<Lit_VarLike "excludes+=">
                            pairs:[
                              (AssignPair
                                left:...0x15aa
                                lhs:(sh_lhs.Name left:...0x15aa name:excludes)
                                op:assign_op.PlusEqual
                                rhs:(w
                                  (word_part.InitializerLiteral
                                    left:<Op_LParen "(">
                                    pairs:[
                                      (InitializerWord.ArrayWord
                                        w:(w <Lit_Chars lowercase>)
                                      )
                                      (InitializerWord.ArrayWord
                                        w:(w <Lit_Chars uppercase>)
                                      )
                                    ]
                                    right:<Right_Initializer ")">
                                  )
                                )
                              )
                            ]
                          )
                        ]
                        right:<Op_DSemiAmp ";;&">
                      )
                      (CaseArm
                        left:<Lit_Star "*">
                        pattern:(pat.Words
                          words:[
                            (w
                              <Lit_Star "*">
                              <Lit_Chars nocontrol>
                              <Lit_Star "*">
                            )
                          ]
                        )
                        middle:<Right_CasePat ")">
                        action:[
                          (command.ShAssignment
                            left:<Lit_VarLike "excludes+=">
                            pairs:[
                              (AssignPair
                                left:...0x1f9e
                                lhs:(sh_lhs.Name left:...0x1f9e name:excludes)
                                op:assign_op.PlusEqual
                                rhs:(w
                                  (word_part.InitializerLiteral
                                    left:<Op_LParen "(">
                                    pairs:[
                                      (InitializerWord.ArrayWord
                                        w:(w <Lit_Chars nocontrol>)
                                      )
                                    ]
                                    right:<Right_Initializer ")">
                                  )
                                )
                              )
                            ]
                          )
                        ]
                        right:<Op_DSemiAmp ";;&">
                      )
                      (CaseArm
                        left:<Lit_Star "*">
                        pattern:(pat.Words
                          words:[
                            (w <Lit_Star "*"> <Lit_Chars ascii> <Lit_Star "*">)
                          ]
                        )
                        middle:<Right_CasePat ")">
                        action:[
                          (command.ShAssignment
                            left:<Lit_VarLike "excludes+=">
                            pairs:[
                              (AssignPair
                                left:...0x1ef6
                                lhs:(sh_lhs.Name left:...0x1ef6 name:excludes)
                                op:assign_op.PlusEqual
                                rhs:(w
                                  (word_part.InitializerLiteral
                                    left:<Op_LParen "(">
                                    pairs:[
                                      (InitializerWord.ArrayWord
                                        w:(w <Lit_Chars ascii>)
                                      )
                                    ]
                                    right:<Right_Initializer ")">
                                  )
                                )
                              )
                            ]
                          )
                        ]
                        right:<Op_DSemi ";;">
                      )
                    ]
                    arms_end:<KW_Esac esac>
                  )
                  (C
                    (w <Lit_Chars local>)
                    (w
                      <Lit_VarLike "excludes_str=">
                      (CommandSub
                        left_token:<Left_DollarParen "$(">
                        child:(command.CommandList
                          children:[
                            (C
                              (w <Lit_Chars export>)
                              (w <Lit_VarLike "IFS="> (SQ "|"))
                            )
                            (C
                              (w <Lit_Chars echo>)
                              (w
                                (DQ
                                  (BracedVarSub
                                    left:<Left_DollarBrace "${">
                                    name_tok:<VSub_Name excludes>
                                    var_name:excludes
                                    bracket_op:(bracket_op.WholeArray
                                      op_id:Arith_Star
                                    )
                                    right:<Right_DollarBrace "}">
                                  )
                                )
                              )
                            )
                          ]
                        )
                        right:<Eof_RParen ")">
                      )
                    )
                  )
                  (C
                    (w <Lit_Chars local>)
                    (w
                      <Lit_VarLike "lastopt=">
                      (BracedVarSub
                        left:<Left_DollarBrace "${">
                        name_tok:<VSub_Name cur>
                        var_name:cur
                        suffix_op:(suffix_op.PatSub
                          pat:(w <Lit_Other "*"> <Lit_Chars ",">)
                          replace:(w)
                          replace_mode:Undefined_Tok
                          slash_tok:<VOp2_Slash />
                        )
                        right:<Right_DollarBrace "}">
                      )
                    )
                    (w <Lit_VarLike "prevopt=">)
                  )
                  (command.AndOr
                    children:[
                      (command.DBracket
                        left:<KW_DLeftBracket "[[">
                        expr:(bool_expr.Binary
                          op_id:BoolBinary_GlobDEqual
                          left:(w ($ cur))
                          right:(w
                            <Lit_Other "*">
                            <Lit_Other ",">
                            <Lit_Other "*">
                          )
                        )
                        right:<Lit_DRightBracket "]]">
                      )
                      (command.ShAssignment
                        left:<Lit_VarLike "prevopt=">
                        pairs:[
                          (AssignPair
                            left:...0x1c32
                            lhs:(sh_lhs.Name left:...0x1c32 name:prevopt)
                            op:assign_op.Equal
                            rhs:(w
                              (BracedVarSub
                                left:<Left_DollarBrace "${">
                                name_tok:<VSub_Name cur>
                                var_name:cur
                                suffix_op:(suffix_op.Unary
                                  op:<VOp1_Percent "%">
                                  arg_word:(w <Lit_Chars ","> <Lit_Other "*">)
                                )
                                right:<Right_DollarBrace "}">
                              )
                              <Lit_Comma ",">
                            )
                          )
                        ]
                      )
                    ]
                    ops:[<Op_DAmp "&&">]
                  )
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -c>)
                    (w (DQ ($ lastopt)))
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -P>)
                    (w (DQ ($ prevopt)))
                    (w <Lit_Chars -X>)
                    (w (DQ <Lit_Chars "@("> ($ excludes_str) <Lit_Chars ")">))
                    (w <Lit_Chars -W>)
                    (w (SQ "unix windows nocontrol ascii lowercase uppercase"))
                  )
                  (C
                    (w <Lit_Chars local>)
                    (w <Lit_Chars -a>)
                    (w <Lit_Chars opt_as_arr>)
                  )
                  (C
                    (w <Lit_Chars _comp_split>)
                    (w <Lit_Chars -F>)
                    (w
                      (SingleQuoted
                        left:<Left_DollarSingleQuote "$'">
                        sval:", \t\n"
                        right:<Right_SingleQuote "'">
                      )
                    )
                    (w <Lit_Chars opt_as_arr>)
                    (w
                      (DQ
                        (BracedVarSub
                          left:<Left_DollarBrace "${">
                          name_tok:<VSub_Name COMPREPLY>
                          var_name:COMPREPLY
                          bracket_op:(bracket_op.ArrayIndex
                            expr:(w <Lit_Digits 0>)
                          )
                          right:<Right_DollarBrace "}">
                        )
                      )
                    )
                  )
                  (command.AndOr
                    children:[
                      (command.DParen
                        left:<Op_DLeftParen "((">
                        child:(arith_expr.Binary
                          op:<Arith_Less "<">
                          left:(w
                            (BracedVarSub
                              left:<Left_DollarBrace "${">
                              name_tok:<VSub_Name opt_as_arr>
                              var_name:opt_as_arr
                              prefix_op:<VSub_Pound "#">
                              bracket_op:(bracket_op.WholeArray op_id:Lit_At)
                              right:<Right_DollarBrace "}">
                            )
                          )
                          right:(w <Lit_Digits 4>)
                        )
                        right:<Op_DRightParen ")">
                      )
                      (C
                        (w <Lit_Chars compopt>)
                        (w <Lit_Chars -o>)
                        (w <Lit_Chars nospace>)
                      )
                    ]
                    ops:[<Op_DAmp "&&">]
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --prefer-family>
                pattern:(pat.Words words:[(w <Lit_Chars --prefer-family>)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ "IPv4 IPv6 none"))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --directory-prefix>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --directory-prefix>)
                    (w <Lit_Chars --ca-directory>)
                    (w <Lit_Chars --warc-tempdir>)
                    (w <Lit_Chars -> (${ VSub_Name noargopts) <Lit_Chars P>)
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (C (w <Lit_Chars _comp_compgen_filedir>) (w <Lit_Chars -d>))
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --output-file>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --output-file>)
                    (w <Lit_Chars --append-output>)
                    (w <Lit_Chars --config>)
                    (w <Lit_Chars --load-cookies>)
                    (w <Lit_Chars --save-cookies>)
                    (w <Lit_Chars --post-file>)
                    (w <Lit_Chars --certificate>)
                    (w <Lit_Chars --ca-certificate>)
                    (w <Lit_Chars --private-key>)
                    (w <Lit_Chars --random-file>)
                    (w <Lit_Chars --egd-file>)
                    (w <Lit_Chars --warc-file>)
                    (w <Lit_Chars --warc-dedup>)
                    (w
                      <Lit_Chars ->
                      (${ VSub_Name noargopts)
                      <Lit_LBracket "[">
                      <Lit_Chars oa>
                      <Lit_RBracket "]">
                    )
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (C (w <Lit_Chars _comp_compgen_filedir>))
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --output-document>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --output-document>)
                    (w <Lit_Chars --input-file>)
                    (w
                      <Lit_Chars ->
                      (${ VSub_Name noargopts)
                      <Lit_LBracket "[">
                      <Lit_Chars Oi>
                      <Lit_RBracket "]">
                    )
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (command.AndOr
                    children:[
                      (C (w <Lit_Chars _comp_compgen_filedir>))
                      (command.DBracket
                        left:<KW_DLeftBracket "[[">
                        expr:(bool_expr.LogicalOr
                          left:(bool_expr.Binary
                            op_id:BoolBinary_GlobDEqual
                            left:(w ($ cur))
                            right:(w <Lit_Chars ->)
                          )
                          right:(bool_expr.LogicalNot
                            child:(bool_expr.WordTest w:(w ($ cur)))
                          )
                        )
                        right:<Lit_DRightBracket "]]">
                      )
                      (command.ShAssignment
                        left:<Lit_VarLike "COMPREPLY+=">
                        pairs:[
                          (AssignPair
                            left:...0x293a
                            lhs:(sh_lhs.Name left:...0x293a name:COMPREPLY)
                            op:assign_op.PlusEqual
                            rhs:(w
                              (word_part.InitializerLiteral
                                left:<Op_LParen "(">
                                pairs:[
                                  (InitializerWord.ArrayWord
                                    w:(w <Lit_Chars ->)
                                  )
                                ]
                                right:<Right_Initializer ")">
                              )
                            )
                          )
                        ]
                      )
                    ]
                    ops:[<Op_DAmp "&&"> <Op_DAmp "&&">]
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --secure-protocol>
                pattern:(pat.Words words:[(w <Lit_Chars --secure-protocol>)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ "auto SSLv2 SSLv3 TLSv1"))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --certificate-type>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --certificate-type>)
                    (w <Lit_Chars --private-key-type>)
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ "PEM DER"))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --follow-tags>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --follow-tags>)
                    (w <Lit_Chars --ignore-tags>)
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars local>)
                    (w
                      <Lit_VarLike "lastopt=">
                      (BracedVarSub
                        left:<Left_DollarBrace "${">
                        name_tok:<VSub_Name cur>
                        var_name:cur
                        suffix_op:(suffix_op.PatSub
                          pat:(w <Lit_Other "*"> <Lit_Chars ",">)
                          replace:(w)
                          replace_mode:Undefined_Tok
                          slash_tok:<VOp2_Slash />
                        )
                        right:<Right_DollarBrace "}">
                      )
                    )
                    (w <Lit_VarLike "prevopt=">)
                  )
                  (command.AndOr
                    children:[
                      (command.DBracket
                        left:<KW_DLeftBracket "[[">
                        expr:(bool_expr.Binary
                          op_id:BoolBinary_GlobDEqual
                          left:(w ($ cur))
                          right:(w
                            <Lit_Other "*">
                            <Lit_Other ",">
                            <Lit_Other "*">
                          )
                        )
                        right:<Lit_DRightBracket "]]">
                      )
                      (command.ShAssignment
                        left:<Lit_VarLike "prevopt=">
                        pairs:[
                          (AssignPair
                            left:...0x25be
                            lhs:(sh_lhs.Name left:...0x25be name:prevopt)
                            op:assign_op.Equal
                            rhs:(w
                              (BracedVarSub
                                left:<Left_DollarBrace "${">
                                name_tok:<VSub_Name cur>
                                var_name:cur
                                suffix_op:(suffix_op.Unary
                                  op:<VOp1_Percent "%">
                                  arg_word:(w <Lit_Chars ","> <Lit_Other "*">)
                                )
                                right:<Right_DollarBrace "}">
                              )
                              <Lit_Comma ",">
                            )
                          )
                        ]
                      )
                    ]
                    ops:[<Op_DAmp "&&">]
                  )
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -c>)
                    (w (DQ ($ lastopt)))
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -P>)
                    (w (DQ ($ prevopt)))
                    (w <Lit_Chars -W>)
                    (w
                      (SQ
                        "a abbr acronym\n                address applet area b base basefont bdo big blockquote body br\n                button caption center cite code col colgroup dd del dir div dfn\n                dl dt em fieldset font form frame frameset h6 head hr html i\n                iframe img input ins isindex kbd label legend li link map menu\n                meta noframes noscript object ol optgroup option p param pre q\n                s samp script select small span strike strong style sub sup\n                table tbody td textarea tfoot th thead title tr tt u ul var\n                xmp"
                      )
                    )
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --tries>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --tries>)
                    (w <Lit_Chars --timeout>)
                    (w <Lit_Chars --dns-timeout>)
                    (w <Lit_Chars --connect-timeout>)
                    (w <Lit_Chars --read-timeout>)
                    (w <Lit_Chars --wait>)
                    (w <Lit_Chars --waitretry>)
                    (w <Lit_Chars --cut-dirs>)
                    (w <Lit_Chars --max-redirect>)
                    (w <Lit_Chars --level>)
                    (w
                      <Lit_Chars ->
                      (${ VSub_Name noargopts)
                      <Lit_LBracket "[">
                      <Lit_Chars tTwl>
                      <Lit_RBracket "]">
                    )
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -aR>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -P>)
                    (w (DQ ($ cur)))
                    (w <Lit_Chars -W>)
                    (w (DQ <Lit_Chars "{0..9}">))
                  )
                  (C
                    (w <Lit_Chars compopt>)
                    (w <Lit_Chars -o>)
                    (w <Lit_Chars nospace>)
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --quota>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --quota>)
                    (w <Lit_Chars --limit-rate>)
                    (w <Lit_Chars --warc-max-size>)
                    (w <Lit_Chars -> (${ VSub_Name noargopts) <Lit_Chars Q>)
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (command.If
                    if_kw:<KW_If if>
                    arms:[
                      (IfArm
                        keyword:...0x2bd6
                        cond:[
                          (command.Sentence
                            child:(command.DBracket
                              left:<KW_DLeftBracket "[[">
                              expr:(bool_expr.Binary
                                op_id:BoolBinary_GlobDEqual
                                left:(w ($ cur))
                                right:(w
                                  <Lit_Other "*">
                                  <Lit_Other "[">
                                  <Lit_Chars km>
                                  <Lit_Other "]">
                                )
                              )
                              right:<Lit_DRightBracket "]]">
                            )
                            terminator:<Op_Semi ";">
                          )
                        ]
                        then_kw:<KW_Then then>
                        action:[
                          (C
                            (w <Lit_Chars _comp_compgen>)
                            (w <Lit_Chars -R>)
                            (w <Lit_Chars -->)
                            (w <Lit_Chars -W>)
                            (w (DQ ($ cur)))
                          )
                        ]
                        then_tok:...0x2b5e
                      )
                      (IfArm
                        keyword:<KW_Elif elif>
                        cond:[
                          (command.Sentence
                            child:(command.DBracket
                              left:<KW_DLeftBracket "[[">
                              expr:(bool_expr.WordTest w:(w ($ cur)))
                              right:<Lit_DRightBracket "]]">
                            )
                            terminator:<Op_Semi ";">
                          )
                        ]
                        then_kw:<KW_Then then>
                        action:[
                          (C
                            (w <Lit_Chars _comp_compgen>)
                            (w <Lit_Chars -R>)
                            (w <Lit_Chars -->)
                            (w <Lit_Chars -P>)
                            (w (DQ ($ cur)))
                            (w <Lit_Chars -W>)
                            (w (DQ <Lit_Chars "{0..9} k m">))
                          )
                          (C
                            (w <Lit_Chars compopt>)
                            (w <Lit_Chars -o>)
                            (w <Lit_Chars nospace>)
                          )
                        ]
                        then_tok:...0x351e
                      )
                    ]
                    else_kw:<KW_Else else>
                    else_action:[
                      (C
                        (w <Lit_Chars _comp_compgen>)
                        (w <Lit_Chars -R>)
                        (w <Lit_Chars -->)
                        (w <Lit_Chars -W>)
                        (w (DQ <Lit_Chars "{0..9}">))
                      )
                      (C
                        (w <Lit_Chars compopt>)
                        (w <Lit_Chars -o>)
                        (w <Lit_Chars nospace>)
                      )
                    ]
                    fi_kw:<KW_Fi fi>
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --user>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --user>)
                    (w <Lit_Chars --http-user>)
                    (w <Lit_Chars --proxy-user>)
                    (w <Lit_Chars --ftp-user>)
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen_split>)
                    (w <Lit_Chars -->)
                    (w
                      (DQ
                        (CommandSub
                          left_token:<Left_DollarParen "$(">
                          child:(C
                            (w <Lit_Chars command>)
                            (w <Lit_Chars sed>)
                            (w <Lit_Chars -n>)
                            (w
                              (SQ "/^login/s/^[[:blank:]]*login[[:blank:]]//p")
                            )
                            (w
                              (word_part.TildeSub left:<Lit_Tilde "~">)
                              <Lit_Slash />
                              <Lit_Chars .netrc>
                            )
                          )
                          right:<Eof_RParen ")">
                        )
                      )
                    )
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --header>
                pattern:(pat.Words words:[(w <Lit_Chars --header>)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w
                      (SQ
                        "Accept Accept-Charset Accept-Encoding\n                Accept-Language Accept-Ranges Age Allow Authorization\n                Cache-Control Connection Content-Encoding Content-Language\n                Content-Length Content-Location Content-MD5 Content-Range\n                Content-Type Date ETag Expect Expires From Host If-Match\n                If-Modified-Since If-None-Match If-Range If-Unmodified-Since\n                Last-Modified Location Max-Forwards Pragma Proxy-Authenticate\n                Proxy-Authorization Range Referer Retry-After Server TE Trailer\n                Transfer-Encoding Upgrade User-Agent Vary Via Warning\n                WWW-Authenticate"
                      )
                    )
                  )
                  (C
                    (w <Lit_Chars compopt>)
                    (w <Lit_Chars -o>)
                    (w <Lit_Chars nospace>)
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --local-encoding>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --local-encoding>)
                    (w <Lit_Chars --remote-encoding>)
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (command.AndOr
                    children:[
                      (C
                        (w <Lit_Chars type>)
                        (w <Lit_Chars -P>)
                        (w <Lit_Chars xauth>)
                      )
                      (C
                        (w <Lit_Chars _comp_compgen>)
                        (w <Lit_Chars -x>)
                        (w <Lit_Chars iconv>)
                        (w <Lit_Chars charsets>)
                      )
                    ]
                    ops:[<Op_DAmp "&&">]
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --execute>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --execute>)
                    (w <Lit_Chars -> (${ VSub_Name noargopts) <Lit_Chars e>)
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --report-speed>
                pattern:(pat.Words words:[(w <Lit_Chars --report-speed>)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ bits))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --regex-type>
                pattern:(pat.Words words:[(w <Lit_Chars --regex-type>)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ posix))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --base>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --base>)
                    (w <Lit_Chars --password>)
                    (w <Lit_Chars --ftp-password>)
                    (w <Lit_Chars --http-password>)
                    (w <Lit_Chars --proxy-password>)
                    (w <Lit_Chars --default-page>)
                    (w <Lit_Chars --referer>)
                    (w <Lit_Chars --user-agent>)
                    (w <Lit_Chars --post-data>)
                    (w <Lit_Chars --warc-header>)
                    (w <Lit_Chars --accept>)
                    (w <Lit_Chars --reject>)
                    (w <Lit_Chars --accept-regex>)
                    (w <Lit_Chars --reject-regex>)
                    (w <Lit_Chars --include-directories>)
                    (w <Lit_Chars --exclude-directories>)
                    (w
                      <Lit_Chars ->
                      (${ VSub_Name noargopts)
                      <Lit_LBracket "[">
                      <Lit_Chars BUARIX>
                      <Lit_RBracket "]">
                    )
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
            ]
            arms_end:<KW_Esac esac>
          )
          (command.AndOr
            children:[
              (command.DBracket
                left:<KW_DLeftBracket "[[">
                expr:(bool_expr.WordTest w:(w ($ was_split)))
                right:<Lit_DRightBracket "]]">
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DAmp "&&">]
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x3e8e
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.Binary
                        op_id:BoolBinary_GlobDEqual
                        left:(w ($ cur))
                        right:(w <Lit_Chars -> <Lit_Other "*">)
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (C (w <Lit_Chars _comp_compgen_help>))
                  (command.AndOr
                    children:[
                      (command.DBracket
                        left:<KW_DLeftBracket "[[">
                        expr:(bool_expr.Binary
                          op_id:BoolBinary_GlobDEqual
                          left:(w
                            (BracedVarSub
                              left:<Left_DollarBrace "${">
                              name_tok:<VSub_Name COMPREPLY>
                              var_name:COMPREPLY
                              suffix_op:(suffix_op.Unary
                                op:<VTest_Hyphen ->
                                arg_word:(w)
                              )
                              right:<Right_DollarBrace "}">
                            )
                          )
                          right:(w <Lit_Other "*"> <BoolBinary_GlobEqual "=">)
                        )
                        right:<Lit_DRightBracket "]]">
                      )
                      (C
                        (w <Lit_Chars compopt>)
                        (w <Lit_Chars -o>)
                        (w <Lit_Chars nospace>)
                      )
                    ]
                    ops:[<Op_DAmp "&&">]
                  )
                ]
                then_tok:...0x3e22
              )
            ]
            else_action:[]
            fi_kw:<KW_Fi fi>
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_wget()\n{\n    local cur prev words cword was_split comp_args\n    _comp_initialize -s -- \"$@\" || return\n\n    local noargopts='!(-*|*[DPoaOitTwlQeBUARIX]*)'\n    # shellcheck disable=SC2254\n    case $prev in\n        --version | --help | -${noargopts}[hV])\n            return\n            ;;\n        --progress)\n            _comp_compgen -- -W 'bar dot'\n            return\n            ;;\n        --bind-address)\n            _comp_compgen_ip_addresses\n            return\n            ;;\n        --domains | --exclude-domains | -${noargopts}D)\n            _comp_compgen_known_hosts -- \"$cur\"\n            return\n            ;;\n        --restrict-file-names)\n            local excludes=()\n            case $cur in\n                *unix* | *windows*)\n                    excludes=(windows unix)\n                    ;;&\n                *lowercase* | *uppercase*)\n                    excludes+=(lowercase uppercase)\n                    ;;&\n                *nocontrol*)\n                    excludes+=(nocontrol)\n                    ;;&\n                *ascii*)\n                    excludes+=(ascii)\n                    ;;\n            esac\n            local excludes_str=$(\n                export IFS='|'\n                echo \"${excludes[*]}\"\n            )\n\n            # prevopt is the previous options string used as a prefix\n            # to avoid COMPREPLY replacing them with the $lastopt completion\n            local lastopt=${cur/*,/} prevopt=\n            [[ $cur == *,* ]] && prevopt=${cur%,*},\n\n            _comp_compgen -c \"$lastopt\" -- -P \"$prevopt\" \\\n                -X \"@($excludes_str)\" \\\n                -W 'unix windows nocontrol ascii lowercase uppercase'\n\n            # +o nospace when no more valid option is possible (= append a space)\n            local -a opt_as_arr\n            _comp_split -F $', \\t\\n' opt_as_arr \"${COMPREPLY[0]}\"\n            ((${#opt_as_arr[@]} < 4)) && compopt -o nospace\n            return\n            ;;\n        --prefer-family)\n            _comp_compgen -- -W 'IPv4 IPv6 none'\n            return\n            ;;\n        --directory-prefix | --ca-directory | --warc-tempdir | -${noargopts}P)\n            _comp_compgen_filedir -d\n            return\n            ;;\n        --output-file | --append-output | --config | --load-cookies | \\\n            --save-cookies | --post-file | --certificate | --ca-certificate | \\\n            --private-key | --random-file | --egd-file | --warc-file | \\\n            --warc-dedup | -${noargopts}[oa])\n            _comp_compgen_filedir\n            return\n            ;;\n        --output-document | --input-file | -${noargopts}[Oi])\n            _comp_compgen_filedir && [[ $cur == - || ! $cur ]] && COMPREPLY+=(-)\n            return\n            ;;\n        --secure-protocol)\n            _comp_compgen -- -W 'auto SSLv2 SSLv3 TLSv1'\n            return\n            ;;\n        --certificate-type | --private-key-type)\n            _comp_compgen -- -W 'PEM DER'\n            return\n            ;;\n        --follow-tags | --ignore-tags)\n            local lastopt=${cur/*,/} prevopt=\n            [[ $cur == *,* ]] && prevopt=${cur%,*},\n\n            _comp_compgen -c \"$lastopt\" -- -P \"$prevopt\" -W 'a abbr acronym\n                address applet area b base basefont bdo big blockquote body br\n                button caption center cite code col colgroup dd del dir div dfn\n                dl dt em fieldset font form frame frameset h6 head hr html i\n                iframe img input ins isindex kbd label legend li link map menu\n                meta noframes noscript object ol optgroup option p param pre q\n                s samp script select small span strike strong style sub sup\n                table tbody td textarea tfoot th thead title tr tt u ul var\n                xmp'\n            return\n            ;;\n        --tries | --timeout | --dns-timeout | --connect-timeout | \\\n            --read-timeout | --wait | --waitretry | --cut-dirs | \\\n            --max-redirect | --level | -${noargopts}[tTwl])\n            # expect integer number\n            _comp_compgen -aR -- -P \"$cur\" -W \"{0..9}\"\n            compopt -o nospace\n            return\n            ;;\n        --quota | --limit-rate | --warc-max-size | -${noargopts}Q)\n            # expect size\n            if [[ $cur == *[km] ]]; then\n                _comp_compgen -R -- -W \"$cur\"\n            elif [[ $cur ]]; then\n                _comp_compgen -R -- -P \"$cur\" -W \"{0..9} k m\"\n                compopt -o nospace\n            else\n                _comp_compgen -R -- -W \"{0..9}\"\n                compopt -o nospace\n            fi\n            return\n            ;;\n        --user | --http-user | --proxy-user | --ftp-user)\n            _comp_compgen_split -- \"$(command sed -n \\\n                '/^login/s/^[[:blank:]]*login[[:blank:]]//p' ~/.netrc \\\n                2>/dev/null)\"\n            return\n            ;;\n        --header)\n            _comp_compgen -- -W 'Accept Accept-Charset Accept-Encoding\n                Accept-Language Accept-Ranges Age Allow Authorization\n                Cache-Control Connection Content-Encoding Content-Language\n                Content-Length Content-Location Content-MD5 Content-Range\n                Content-Type Date ETag Expect Expires From Host If-Match\n                If-Modified-Since If-None-Match If-Range If-Unmodified-Since\n                Last-Modified Location Max-Forwards Pragma Proxy-Authenticate\n                Proxy-Authorization Range Referer Retry-After Server TE Trailer\n                Transfer-Encoding Upgrade User-Agent Vary Via Warning\n                WWW-Authenticate'\n            compopt -o nospace\n            return\n            ;;\n        --local-encoding | --remote-encoding)\n            type -P xauth &>/dev/null && _comp_compgen -x iconv charsets\n            return\n            ;;\n        --execute | -${noargopts}e)\n            return # TODO base=STR\n            ;;\n        --report-speed)\n            _comp_compgen -- -W 'bits'\n            return\n            ;;\n        --regex-type)\n            _comp_compgen -- -W 'posix'\n            return\n            ;;\n        --base | --password | --ftp-password | --http-password | \\\n            --proxy-password | --default-page | --referer | --user-agent | \\\n            --post-data | --warc-header | --accept | --reject | \\\n            --accept-regex | --reject-regex | --include-directories | \\\n            --exclude-directories | -${noargopts}[BUARIX])\n            # argument required but no completions available\n            return\n            ;;\n    esac\n\n    [[ $was_split ]] && return\n\n    if [[ $cur == -* ]]; then\n        _comp_compgen_help\n        [[ ${COMPREPLY-} == *= ]] && compopt -o nospace\n    fi\n\n}"
    )
    (C
      (w <Lit_Chars complete>)
      (w <Lit_Chars -F>)
      (w <Lit_Chars _comp_cmd_wget>)
      (w <Lit_Chars wget>)
    )
  ]
  ops:[<Op_DAmp "&&">]
)
(command.AndOr
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_wine>
      name:_comp_cmd_wine
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars cur>)
            (w <Lit_Chars prev>)
            (w <Lit_Chars words>)
            (w <Lit_Chars cword>)
            (w <Lit_Chars comp_args>)
          )
          (command.AndOr
            children:[
              (C
                (w <Lit_Chars _comp_initialize>)
                (w <Lit_Chars -->)
                (w (DQ ($ VSub_At)))
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DPipe "||">]
          )
          (command.Case
            case_kw:<KW_Case case>
            to_match:(case_arg.Word w:(w ($ prev)))
            arms_start:<KW_In in>
            arms:[
              (CaseArm
                left:<Lit_Chars --help>
                pattern:(pat.Words
                  words:[(w <Lit_Chars --help>) (w <Lit_Chars --version>)]
                )
                middle:<Right_CasePat ")">
                action:[
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
            ]
            arms_end:<KW_Esac esac>
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x1a6e
                cond:[
                  (command.Sentence
                    child:(command.DParen
                      left:<Op_DLeftParen "((">
                      child:(arith_expr.Binary
                        op:<Arith_DEqual "==">
                        left:<Lit_ArithVarLike cword>
                        right:(w <Lit_Digits 1>)
                      )
                      right:<Op_DRightParen ")">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (command.If
                    if_kw:<KW_If if>
                    arms:[
                      (IfArm
                        keyword:...0x1a02
                        cond:[
                          (command.Sentence
                            child:(command.DBracket
                              left:<KW_DLeftBracket "[[">
                              expr:(bool_expr.Binary
                                op_id:BoolBinary_GlobDEqual
                                left:(w ($ cur))
                                right:(w <Lit_Chars -> <Lit_Other "*">)
                              )
                              right:<Lit_DRightBracket "]]">
                            )
                            terminator:<Op_Semi ";">
                          )
                        ]
                        then_kw:<KW_Then then>
                        action:[
                          (C
                            (w <Lit_Chars _comp_compgen>)
                            (w <Lit_Chars -->)
                            (w <Lit_Chars -W>)
                            (w (SQ "--help --version"))
                          )
                          (command.AndOr
                            children:[
                              (command.DBracket
                                left:<KW_DLeftBracket "[[">
                                expr:(bool_expr.WordTest
                                  w:(w
                                    (BracedVarSub
                                      left:<Left_DollarBrace "${">
                                      name_tok:<VSub_Name COMPREPLY>
                                      var_name:COMPREPLY
                                      suffix_op:(suffix_op.Unary
                                        op:<VTest_Hyphen ->
                                        arg_word:(w)
                                      )
                                      right:<Right_DollarBrace "}">
                                    )
                                  )
                                )
                                right:<Lit_DRightBracket "]]">
                              )
                              (command.ControlFlow
                                keyword:<ControlFlow_Return return>
                              )
                            ]
                            ops:[<Op_DAmp "&&">]
                          )
                        ]
                        then_tok:...0x1996
                      )
                    ]
                    else_action:[]
                    fi_kw:<KW_Fi fi>
                  )
                  (C
                    (w <Lit_Chars _comp_compgen_filedir>)
                    (w
                      (SQ
                        "@([bB][aA][tT]|[cC][mM][dD]|[eE][xX][eE]?(.[sS][oO])|[cC][oO][mM]|[sS][cC][rR]|[mM][sS][iI])"
                      )
                    )
                  )
                ]
                then_tok:...0x1a1e
              )
            ]
            else_kw:<KW_Else else>
            else_action:[(C (w <Lit_Chars _comp_compgen_filedir>))]
            fi_kw:<KW_Fi fi>
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_wine()\n{\n    local cur prev words cword comp_args\n    _comp_initialize -- \"$@\" || return\n\n    case $prev in\n        --help | --version)\n            return\n            ;;\n    esac\n\n    if ((cword == 1)); then\n        if [[ $cur == -* ]]; then\n            _comp_compgen -- -W '--help --version'\n            [[ ${COMPREPLY-} ]] && return\n        fi\n        _comp_compgen_filedir '@([bB][aA][tT]|[cC][mM][dD]|[eE][xX][eE]?(.[sS][oO])|[cC][oO][mM]|[sS][cC][rR]|[mM][sS][iI])'\n    else\n        _comp_compgen_filedir\n    fi\n}"
    )
    (C
      (w <Lit_Chars complete>)
      (w <Lit_Chars -F>)
      (w <Lit_Chars _comp_cmd_wine>)
      (word.BracedTree
        parts:[
          <Lit_Chars wine>
          (word_part.BracedTuple words:[(w) (w <Lit_Number 64>)])
          (word_part.BracedTuple
            words:[(w) (w <Lit_Chars -development>) (w <Lit_Chars -stable>)]
          )
        ]
      )
    )
  ]
  ops:[<Op_DAmp "&&">]
)
(command.AndOr
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_withlist>
      name:_comp_cmd_withlist
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars cur>)
            (w <Lit_Chars prev>)
            (w <Lit_Chars words>)
            (w <Lit_Chars cword>)
            (w <Lit_Chars comp_args>)
          )
          (command.AndOr
            children:[
              (C
                (w <Lit_Chars _comp_initialize>)
                (w <Lit_Chars -->)
                (w (DQ ($ VSub_At)))
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DPipe "||">]
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x109a
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.Binary
                        op_id:BoolBinary_GlobDEqual
                        left:(w ($ cur))
                        right:(w <Lit_Chars -> <Lit_Other "*">)
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ "--lock --interactive --run --all --quiet --help"))
                  )
                ]
                then_tok:...0x102e
              )
            ]
            else_kw:<KW_Else else>
            else_action:[
              (C (w <Lit_Chars local>) (w <Lit_Chars pathcmd>))
              (command.AndOr
                children:[
                  (command.ShAssignment
                    left:<Lit_VarLike "pathcmd=">
                    pairs:[
                      (AssignPair
                        left:...0x19ca
                        lhs:(sh_lhs.Name left:...0x19ca name:pathcmd)
                        op:assign_op.Equal
                        rhs:(w
                          (CommandSub
                            left_token:<Left_DollarParen "$(">
                            child:(C
                              (w <Lit_Chars type>)
                              (w <Lit_Chars -P>)
                              (w <Lit_Chars -->)
                              (w (DQ ($ 1)))
                            )
                            right:<Eof_RParen ")">
                          )
                        )
                      )
                    ]
                  )
                  (C
                    (w <Lit_Chars local>)
                    (w
                      <Lit_VarLike "PATH=">
                      (BracedVarSub
                        left:<Left_DollarBrace "${">
                        name_tok:<VSub_Name pathcmd>
                        var_name:pathcmd
                        suffix_op:(suffix_op.Unary
                          op:<VOp1_Percent "%">
                          arg_word:(w <Lit_Slash /> <Lit_Other "*">)
                        )
                        right:<Right_DollarBrace "}">
                      )
                      <Lit_Colon ":">
                      ($ PATH)
                    )
                  )
                ]
                ops:[<Op_DAmp "&&">]
              )
              (C
                (w <Lit_Chars _comp_compgen>)
                (w <Lit_Chars -x>)
                (w <Lit_Chars list_lists>)
                (w <Lit_Chars mailman_lists>)
              )
            ]
            fi_kw:<KW_Fi fi>
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_withlist()\n{\n    local cur prev words cword comp_args\n    _comp_initialize -- \"$@\" || return\n\n    if [[ $cur == -* ]]; then\n        _comp_compgen -- -W '--lock --interactive --run --all --quiet --help'\n    else\n        # Prefer `list_lists` in the same dir as command\n        local pathcmd\n        pathcmd=$(type -P -- \"$1\") && local PATH=${pathcmd%/*}:$PATH\n        _comp_compgen -x list_lists mailman_lists\n    fi\n\n}"
    )
    (C
      (w <Lit_Chars complete>)
      (w <Lit_Chars -F>)
      (w <Lit_Chars _comp_cmd_withlist>)
      (w <Lit_Chars withlist>)
    )
  ]
  ops:[<Op_DAmp "&&">]
)
(command.AndOr
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_wodim>
      name:_comp_cmd_wodim
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars cur>)
            (w <Lit_Chars prev>)
            (w <Lit_Chars words>)
            (w <Lit_Chars cword>)
            (w <Lit_Chars comp_args>)
          )
          (command.AndOr
            children:[
              (C
                (w <Lit_Chars _comp_initialize>)
                (w <Lit_Chars -n>)
                (w <Lit_Equals "=">)
                (w <Lit_Chars -->)
                (w (DQ ($ VSub_At)))
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DPipe "||">]
          )
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars generic_options>)
            (w <Lit_Chars track_options>)
            (w <Lit_Chars track_mode>)
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x1012
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.Binary
                        op_id:BoolBinary_GlobDEqual
                        left:(w ($ cur))
                        right:(w
                          <Lit_Other "*">
                          <BoolBinary_GlobEqual "=">
                          <Lit_Other "*">
                        )
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (command.ShAssignment
                    left:<Lit_VarLike "prev=">
                    pairs:[
                      (AssignPair
                        left:...0x1a2a
                        lhs:(sh_lhs.Name left:...0x1a2a name:prev)
                        op:assign_op.Equal
                        rhs:(w
                          (BracedVarSub
                            left:<Left_DollarBrace "${">
                            name_tok:<VSub_Name cur>
                            var_name:cur
                            suffix_op:(suffix_op.Unary
                              op:<VOp1_DPercent "%%">
                              arg_word:(w <Lit_Chars "="> <Lit_Other "*">)
                            )
                            right:<Right_DollarBrace "}">
                          )
                        )
                      )
                    ]
                  )
                  (command.ShAssignment
                    left:<Lit_VarLike "cur=">
                    pairs:[
                      (AssignPair
                        left:...0x19d6
                        lhs:(sh_lhs.Name left:...0x19d6 name:cur)
                        op:assign_op.Equal
                        rhs:(w
                          (BracedVarSub
                            left:<Left_DollarBrace "${">
                            name_tok:<VSub_Name cur>
                            var_name:cur
                            suffix_op:(suffix_op.Unary
                              op:<VOp1_Pound "#">
                              arg_word:(w <Lit_Other "*"> <Lit_Chars "=">)
                            )
                            right:<Right_DollarBrace "}">
                          )
                        )
                      )
                    ]
                  )
                  (command.Case
                    case_kw:<KW_Case case>
                    to_match:(case_arg.Word w:(w ($ prev)))
                    arms_start:<KW_In in>
                    arms:[
                      (CaseArm
                        left:<Lit_Chars textfile>
                        pattern:(pat.Words
                          words:[
                            (w <Lit_Chars textfile>)
                            (w <Lit_Chars cuefile>)
                            (w <Lit_Chars msifile>)
                          ]
                        )
                        middle:<Right_CasePat ")">
                        action:[(C (w <Lit_Chars _comp_compgen_filedir>))]
                        right:<Op_DSemi ";;">
                      )
                      (CaseArm
                        left:<Lit_Chars blank>
                        pattern:(pat.Words words:[(w <Lit_Chars blank>)])
                        middle:<Right_CasePat ")">
                        action:[
                          (C
                            (w <Lit_Chars _comp_compgen>)
                            (w <Lit_Chars -->)
                            (w <Lit_Chars -W>)
                            (w
                              (SQ
                                "help all fast track unreserve trtail\n                    unclose session"
                              )
                            )
                          )
                        ]
                        right:<Op_DSemi ";;">
                      )
                      (CaseArm
                        left:<Lit_Chars driveropts>
                        pattern:(pat.Words words:[(w <Lit_Chars driveropts>)])
                        middle:<Right_CasePat ")">
                        action:[
                          (command.If
                            if_kw:<KW_If if>
                            arms:[
                              (IfArm
                                keyword:...0x17ce
                                cond:[
                                  (command.Sentence
                                    child:(command.DBracket
                                      left:<KW_DLeftBracket "[[">
                                      expr:(bool_expr.Binary
                                        op_id:BoolBinary_GlobDEqual
                                        left:(w ($ cur))
                                        right:(w
                                          <Lit_Other "*">
                                          <BoolBinary_GlobEqual "=">
                                          <Lit_Other "*">
                                        )
                                      )
                                      right:<Lit_DRightBracket "]]">
                                    )
                                    terminator:<Op_Semi ";">
                                  )
                                ]
                                then_kw:<KW_Then then>
                                action:[
                                  (command.ShAssignment
                                    left:<Lit_VarLike "prev=">
                                    pairs:[
                                      (AssignPair
                                        left:...0x173e
                                        lhs:(sh_lhs.Name
                                          left:...0x173e
                                          name:prev
                                        )
                                        op:assign_op.Equal
                                        rhs:(w
                                          (BracedVarSub
                                            left:<Left_DollarBrace "${">
                                            name_tok:<VSub_Name cur>
                                            var_name:cur
                                            suffix_op:(suffix_op.Unary
                                              op:<VOp1_DPercent "%%">
                                              arg_word:(w
                                                <Lit_Chars "=">
                                                <Lit_Other "*">
                                              )
                                            )
                                            right:<Right_DollarBrace "}">
                                          )
                                        )
                                      )
                                    ]
                                  )
                                  (command.ShAssignment
                                    left:<Lit_VarLike "cur=">
                                    pairs:[
                                      (AssignPair
                                        left:...0x16ee
                                        lhs:(sh_lhs.Name
                                          left:...0x16ee
                                          name:cur
                                        )
                                        op:assign_op.Equal
                                        rhs:(w
                                          (BracedVarSub
                                            left:<Left_DollarBrace "${">
                                            name_tok:<VSub_Name cur>
                                            var_name:cur
                                            suffix_op:(suffix_op.Unary
                                              op:<VOp1_Pound "#">
                                              arg_word:(w
                                                <Lit_Other "*">
                                                <Lit_Chars "=">
                                              )
                                            )
                                            right:<Right_DollarBrace "}">
                                          )
                                        )
                                      )
                                    ]
                                  )
                                  (command.Case
                                    case_kw:<KW_Case case>
                                    to_match:(case_arg.Word w:(w ($ prev)))
                                    arms_start:<KW_In in>
                                    arms:[
                                      (CaseArm
                                        left:<Lit_Chars varirec>
                                        pattern:(pat.Words
                                          words:[(w <Lit_Chars varirec>)]
                                        )
                                        middle:<Right_CasePat ")">
                                        action:[
                                          (C
                                            (w <Lit_Chars _comp_compgen>)
                                            (w <Lit_Chars -->)
                                            (w <Lit_Chars -W>)
                                            (w (DQ <Lit_Chars "-2 -1 0 1 2">))
                                          )
                                        ]
                                        right:<Op_DSemi ";;">
                                      )
                                      (CaseArm
                                        left:<Lit_Chars gigarec>
                                        pattern:(pat.Words
                                          words:[(w <Lit_Chars gigarec>)]
                                        )
                                        middle:<Right_CasePat ")">
                                        action:[
                                          (C
                                            (w <Lit_Chars _comp_compgen>)
                                            (w <Lit_Chars -->)
                                            (w <Lit_Chars -W>)
                                            (w
                                              (DQ
                                                <
                                                  Lit_Chars
                                                  "0.6 0.7 0.8 1.0 1.2 1.3 1.4"
                                                >
                                              )
                                            )
                                          )
                                        ]
                                        right:<Op_DSemi ";;">
                                      )
                                      (CaseArm
                                        left:<Lit_Chars tattoofile>
                                        pattern:(pat.Words
                                          words:[(w <Lit_Chars tattoofile>)]
                                        )
                                        middle:<Right_CasePat ")">
                                        action:[
                                          (C
                                            (w
                                              <Lit_Chars _comp_compgen_filedir>
                                            )
                                          )
                                        ]
                                        right:<Op_DSemi ";;">
                                      )
                                    ]
                                    arms_end:<KW_Esac esac>
                                  )
                                ]
                                then_tok:...0x175a
                              )
                            ]
                            else_kw:<KW_Else else>
                            else_action:[
                              (C
                                (w <Lit_Chars _comp_compgen>)
                                (w <Lit_Chars -->)
                                (w <Lit_Chars -W>)
                                (w
                                  (SQ
                                    "burnfree noburnfree varirec= gigarec=\n                        audiomaster forcespeed noforcespeed speedread\n                        nospeedread singlesession nosinglesession hidecdr\n                        nohidecdr tattooinfo tattoofile="
                                  )
                                )
                              )
                              (command.AndOr
                                children:[
                                  (command.DBracket
                                    left:<KW_DLeftBracket "[[">
                                    expr:(bool_expr.Binary
                                      op_id:BoolBinary_GlobDEqual
                                      left:(w
                                        (BracedVarSub
                                          left:<Left_DollarBrace "${">
                                          name_tok:<VSub_Name COMPREPLY>
                                          var_name:COMPREPLY
                                          suffix_op:(suffix_op.Unary
                                            op:<VTest_Hyphen ->
                                            arg_word:(w)
                                          )
                                          right:<Right_DollarBrace "}">
                                        )
                                      )
                                      right:(w
                                        <Lit_Other "*">
                                        <BoolBinary_GlobEqual "=">
                                      )
                                    )
                                    right:<Lit_DRightBracket "]]">
                                  )
                                  (C
                                    (w <Lit_Chars compopt>)
                                    (w <Lit_Chars -o>)
                                    (w <Lit_Chars nospace>)
                                  )
                                ]
                                ops:[<Op_DAmp "&&">]
                              )
                            ]
                            fi_kw:<KW_Fi fi>
                          )
                        ]
                        right:<Op_DSemi ";;">
                      )
                      (CaseArm
                        left:<Lit_Chars driver>
                        pattern:(pat.Words words:[(w <Lit_Chars driver>)])
                        middle:<Right_CasePat ")">
                        action:[
                          (C
                            (w <Lit_Chars _comp_compgen_split>)
                            (w <Lit_Chars -->)
                            (w
                              (DQ
                                (CommandSub
                                  left_token:<Left_DollarParen "$(">
                                  child:(command.Pipeline
                                    children:[
                                      (C
                                        (w (DQ ($ 1)))
                                        (w
                                          <Lit_VarLike "driver=">
                                          <Lit_Chars help>
                                        )
                                      )
                                      (C
                                        (w <Lit_Chars _comp_awk>)
                                        (w (SQ "NR > 1 { print $1 }"))
                                      )
                                    ]
                                    ops:[<Op_Pipe "|">]
                                  )
                                  right:<Eof_RParen ")">
                                )
                                <Lit_Chars " help">
                              )
                            )
                          )
                        ]
                        right:<Op_DSemi ";;">
                      )
                      (CaseArm
                        left:<Lit_Chars minbuf>
                        pattern:(pat.Words words:[(w <Lit_Chars minbuf>)])
                        middle:<Right_CasePat ")">
                        action:[
                          (C
                            (w <Lit_Chars _comp_compgen>)
                            (w <Lit_Chars -->)
                            (w <Lit_Chars -W>)
                            (w (SQ "{25..95}"))
                          )
                        ]
                        right:<Op_DSemi ";;">
                      )
                    ]
                    arms_end:<KW_Esac esac>
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                then_tok:...0x1a4a
              )
            ]
            else_action:[]
            fi_kw:<KW_Fi fi>
          )
          (command.ShAssignment
            left:<Lit_VarLike "generic_options=">
            pairs:[
              (AssignPair
                left:...0x1ac6
                lhs:(sh_lhs.Name left:...0x1ac6 name:generic_options)
                op:assign_op.Equal
                rhs:(w
                  (word_part.InitializerLiteral
                    left:<Op_LParen "(">
                    pairs:[
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -version>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -v>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -V>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -d>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -silent>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -force>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -immed>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -dummy>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -clone>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -dao>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -sao>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -tao>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -raw>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -raw96r>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -raw96p>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -raw16>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -multi>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -msinfo>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -toc>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -atip>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -fix>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -nofix>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -waiti>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -load>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -lock>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -eject>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -format>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -setdropts>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -checkdrive>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -prcap>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -inq>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -scanbus>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars --devices>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -reset>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -abort>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -overburn>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -ignsize>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -useinfo>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -packet>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -noclose>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -text>))
                      (InitializerWord.ArrayWord
                        w:(w (DQ <Lit_Chars "debug=">))
                      )
                      (InitializerWord.ArrayWord
                        w:(w (DQ <Lit_Chars "kdebug=">))
                      )
                      (InitializerWord.ArrayWord
                        w:(w (DQ <Lit_Chars "minbuf=">))
                      )
                      (InitializerWord.ArrayWord
                        w:(w (DQ <Lit_Chars "msifile=">))
                      )
                      (InitializerWord.ArrayWord
                        w:(w (DQ <Lit_Chars "speed=">))
                      )
                      (InitializerWord.ArrayWord
                        w:(w (DQ <Lit_Chars "blank=">))
                      )
                      (InitializerWord.ArrayWord w:(w (DQ <Lit_Chars "fs=">)))
                      (InitializerWord.ArrayWord w:(w (DQ <Lit_Chars "ts=">)))
                      (InitializerWord.ArrayWord w:(w (DQ <Lit_Chars "dev=">)))
                      (InitializerWord.ArrayWord
                        w:(w (DQ <Lit_Chars "gracetime=">))
                      )
                      (InitializerWord.ArrayWord
                        w:(w (DQ <Lit_Chars "timeout=">))
                      )
                      (InitializerWord.ArrayWord
                        w:(w (DQ <Lit_Chars "driver=">))
                      )
                      (InitializerWord.ArrayWord
                        w:(w (DQ <Lit_Chars "driveropts=">))
                      )
                      (InitializerWord.ArrayWord
                        w:(w (DQ <Lit_Chars "defpregap=">))
                      )
                      (InitializerWord.ArrayWord
                        w:(w (DQ <Lit_Chars "pktsize=">))
                      )
                      (InitializerWord.ArrayWord w:(w (DQ <Lit_Chars "mcn=">)))
                      (InitializerWord.ArrayWord
                        w:(w (DQ <Lit_Chars "textfile=">))
                      )
                      (InitializerWord.ArrayWord
                        w:(w (DQ <Lit_Chars "cuefile=">))
                      )
                    ]
                    right:<Right_Initializer ")">
                  )
                )
              )
            ]
          )
          (command.ShAssignment
            left:<Lit_VarLike "track_options=">
            pairs:[
              (AssignPair
                left:...0x2102
                lhs:(sh_lhs.Name left:...0x2102 name:track_options)
                op:assign_op.Equal
                rhs:(w
                  (word_part.InitializerLiteral
                    left:<Op_LParen "(">
                    pairs:[
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -audio>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -swab>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -data>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -mode2>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -xa>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -xa1>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -xa2>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -xamix>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -cdi>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -isosize>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -pad>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -nopad>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -shorttrack>))
                      (InitializerWord.ArrayWord
                        w:(w <Lit_Chars -noshorttrack>)
                      )
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -preemp>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -nopreemp>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -copy>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -nocopy>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars -scms>))
                      (InitializerWord.ArrayWord w:(w (DQ <Lit_Chars "isrc=">)))
                      (InitializerWord.ArrayWord
                        w:(w (DQ <Lit_Chars "index=">))
                      )
                      (InitializerWord.ArrayWord
                        w:(w (DQ <Lit_Chars "padsize=">))
                      )
                      (InitializerWord.ArrayWord
                        w:(w (DQ <Lit_Chars "pregap=">))
                      )
                      (InitializerWord.ArrayWord
                        w:(w (DQ <Lit_Chars "tsize=">))
                      )
                    ]
                    right:<Right_Initializer ")">
                  )
                )
              )
            ]
          )
          (command.ShAssignment
            left:<Lit_VarLike "track_mode=">
            pairs:[
              (AssignPair
                left:...0x29c2
                lhs:(sh_lhs.Name left:...0x29c2 name:track_mode)
                op:assign_op.Equal
                rhs:(w (DQ))
              )
            ]
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x296e
                cond:[
                  (command.Sentence
                    child:(command.DParen
                      left:<Op_DLeftParen "((">
                      child:(arith_expr.Binary
                        op:<Arith_Great ">">
                        left:<Lit_ArithVarLike cword>
                        right:(w <Lit_Digits 1>)
                      )
                      right:<Op_DRightParen ")">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (command.If
                    if_kw:<KW_If if>
                    arms:[
                      (IfArm
                        keyword:...0x2902
                        cond:[
                          (command.Sentence
                            child:(command.DBracket
                              left:<KW_DLeftBracket "[[">
                              expr:(bool_expr.Unary
                                op_id:BoolUnary_f
                                child:(w ($ prev))
                              )
                              right:<Lit_DRightBracket "]]">
                            )
                            terminator:<Op_Semi ";">
                          )
                        ]
                        then_kw:<KW_Then then>
                        action:[
                          (command.ShAssignment
                            left:<Lit_VarLike "track_mode=">
                            pairs:[
                              (AssignPair
                                left:...0x288a
                                lhs:(sh_lhs.Name left:...0x288a name:track_mode)
                                op:assign_op.Equal
                                rhs:(w <Lit_Chars set>)
                              )
                            ]
                          )
                        ]
                        then_tok:...0x28aa
                      )
                    ]
                    else_kw:<KW_Else else>
                    else_action:[
                      (C (w <Lit_Chars local>) (w <Lit_Chars opt>))
                      (command.ForEach
                        keyword:<KW_For for>
                        iter_names:[opt]
                        iterable:(for_iter.Words
                          words:[
                            (w
                              (DQ
                                (BracedVarSub
                                  left:<Left_DollarBrace "${">
                                  name_tok:<VSub_Name track_options>
                                  var_name:track_options
                                  bracket_op:(bracket_op.WholeArray
                                    op_id:Lit_At
                                  )
                                  right:<Right_DollarBrace "}">
                                )
                              )
                            )
                          ]
                        )
                        semi_tok:<Op_Semi ";">
                        body:(command.DoGroup
                          left:<KW_Do do>
                          children:[
                            (command.If
                              if_kw:<KW_If if>
                              arms:[
                                (IfArm
                                  keyword:...0x274e
                                  cond:[
                                    (command.Sentence
                                      child:(command.DBracket
                                        left:<KW_DLeftBracket "[[">
                                        expr:(bool_expr.Binary
                                          op_id:BoolBinary_GlobDEqual
                                          left:(w ($ opt))
                                          right:(w (DQ ($ prev)))
                                        )
                                        right:<Lit_DRightBracket "]]">
                                      )
                                      terminator:<Op_Semi ";">
                                    )
                                  ]
                                  then_kw:<KW_Then then>
                                  action:[
                                    (command.ShAssignment
                                      left:<Lit_VarLike "track_mode=">
                                      pairs:[
                                        (AssignPair
                                          left:...0x26ba
                                          lhs:(sh_lhs.Name
                                            left:...0x26ba
                                            name:track_mode
                                          )
                                          op:assign_op.Equal
                                          rhs:(w <Lit_Chars set>)
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      keyword:<ControlFlow_Break break>
                                    )
                                  ]
                                  then_tok:...0x26d6
                                )
                              ]
                              else_action:[]
                              fi_kw:<KW_Fi fi>
                            )
                          ]
                          right:<KW_Done done>
                        )
                      )
                    ]
                    fi_kw:<KW_Fi fi>
                  )
                ]
                then_tok:...0x291e
              )
            ]
            else_action:[]
            fi_kw:<KW_Fi fi>
          )
          (C (w <Lit_Chars _comp_compgen_filedir>))
          (C
            (w <Lit_Chars _comp_compgen>)
            (w <Lit_Chars -a>)
            (w <Lit_Chars -->)
            (w <Lit_Chars -W>)
            (w (SQ "\"${track_options[@]}\""))
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x2f66
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.LogicalNot
                        child:(bool_expr.WordTest w:(w ($ track_mode)))
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -a>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ "\"${generic_options[@]}\""))
                  )
                ]
                then_tok:...0x2f0e
              )
            ]
            else_action:[]
            fi_kw:<KW_Fi fi>
          )
          (command.AndOr
            children:[
              (command.DBracket
                left:<KW_DLeftBracket "[[">
                expr:(bool_expr.Binary
                  op_id:BoolBinary_GlobDEqual
                  left:(w
                    (BracedVarSub
                      left:<Left_DollarBrace "${">
                      name_tok:<VSub_Name COMPREPLY>
                      var_name:COMPREPLY
                      suffix_op:(suffix_op.Unary
                        op:<VTest_Hyphen ->
                        arg_word:(w)
                      )
                      right:<Right_DollarBrace "}">
                    )
                  )
                  right:(w <Lit_Other "*"> <BoolBinary_GlobEqual "=">)
                )
                right:<Lit_DRightBracket "]]">
              )
              (C
                (w <Lit_Chars compopt>)
                (w <Lit_Chars -o>)
                (w <Lit_Chars nospace>)
              )
            ]
            ops:[<Op_DAmp "&&">]
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_wodim()\n{\n    local cur prev words cword comp_args\n    _comp_initialize -n = -- \"$@\" || return\n\n    local generic_options track_options track_mode\n\n    # foo=bar style option\n    if [[ $cur == *=* ]]; then\n        prev=${cur%%=*}\n        cur=${cur#*=}\n        case $prev in\n            textfile | cuefile | msifile)\n                _comp_compgen_filedir\n                ;;\n            blank)\n                _comp_compgen -- -W 'help all fast track unreserve trtail\n                    unclose session'\n                ;;\n            driveropts)\n                if [[ $cur == *=* ]]; then\n                    prev=${cur%%=*}\n                    cur=${cur#*=}\n                    case $prev in\n                        varirec)\n                            _comp_compgen -- -W \"-2 -1 0 1 2\"\n                            ;;\n                        gigarec)\n                            _comp_compgen -- -W \"0.6 0.7 0.8 1.0 1.2 1.3 1.4\"\n                            ;;\n                        tattoofile)\n                            _comp_compgen_filedir\n                            ;;\n                    esac\n                else\n                    _comp_compgen -- -W 'burnfree noburnfree varirec= gigarec=\n                        audiomaster forcespeed noforcespeed speedread\n                        nospeedread singlesession nosinglesession hidecdr\n                        nohidecdr tattooinfo tattoofile='\n                    [[ ${COMPREPLY-} == *= ]] && compopt -o nospace\n                fi\n                ;;\n            driver)\n                _comp_compgen_split -- \"$(\"$1\" driver=help 2>&1 |\n                    _comp_awk 'NR > 1 { print $1 }') help\"\n                ;;\n            minbuf)\n                _comp_compgen -- -W '{25..95}'\n                ;;\n        esac\n        return\n    fi\n\n    generic_options=(-version -v -V -d -silent -force -immed -dummy -clone\n        -dao -sao -tao -raw -raw96r -raw96p -raw16 -multi -msinfo -toc -atip\n        -fix -nofix -waiti -load -lock -eject -format -setdropts -checkdrive\n        -prcap -inq -scanbus --devices -reset -abort -overburn -ignsize\n        -useinfo -packet -noclose -text \"debug=\" \"kdebug=\" \"minbuf=\"\n        \"msifile=\" \"speed=\" \"blank=\" \"fs=\" \"ts=\" \"dev=\" \"gracetime=\"\n        \"timeout=\" \"driver=\" \"driveropts=\" \"defpregap=\" \"pktsize=\" \"mcn=\"\n        \"textfile=\" \"cuefile=\")\n    track_options=(-audio -swab -data -mode2 -xa -xa1 -xa2 -xamix -cdi\n        -isosize -pad -nopad -shorttrack -noshorttrack -preemp -nopreemp\n        -copy -nocopy -scms \"isrc=\" \"index=\" \"padsize=\" \"pregap=\" \"tsize=\")\n    # look if previous was either a file or a track option\n    track_mode=\"\"\n    if ((cword > 1)); then\n        if [[ -f $prev ]]; then\n            track_mode=set\n        else\n            local opt\n            for opt in \"${track_options[@]}\"; do\n                if [[ $opt == \"$prev\" ]]; then\n                    track_mode=set\n                    break\n                fi\n            done\n        fi\n    fi\n\n    # files are always eligible completion\n    _comp_compgen_filedir\n    # track options are always available\n    _comp_compgen -a -- -W '\"${track_options[@]}\"'\n    # general options are no more available after file or track option\n    if [[ ! $track_mode ]]; then\n        _comp_compgen -a -- -W '\"${generic_options[@]}\"'\n    fi\n    [[ ${COMPREPLY-} == *= ]] && compopt -o nospace\n}"
    )
    (C
      (w <Lit_Chars complete>)
      (w <Lit_Chars -F>)
      (w <Lit_Chars _comp_cmd_wodim>)
      (w <Lit_Chars wodim>)
      (w <Lit_Chars cdrecord>)
    )
  ]
  ops:[<Op_DAmp "&&">]
)
(command.AndOr
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_wol>
      name:_comp_cmd_wol
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars cur>)
            (w <Lit_Chars prev>)
            (w <Lit_Chars words>)
            (w <Lit_Chars cword>)
            (w <Lit_Chars was_split>)
            (w <Lit_Chars comp_args>)
          )
          (command.AndOr
            children:[
              (C
                (w <Lit_Chars _comp_initialize>)
                (w <Lit_Chars -s>)
                (w <Lit_Chars -n>)
                (w <Lit_Colon ":">)
                (w <Lit_Chars -->)
                (w (DQ ($ VSub_At)))
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DPipe "||">]
          )
          (C
            (w <Lit_Chars local>)
            (w <Lit_VarLike "noargopts="> (SQ "!(-*|*[pwhif]*)"))
          )
          (command.Case
            case_kw:<KW_Case case>
            to_match:(case_arg.Word w:(w ($ prev)))
            arms_start:<KW_In in>
            arms:[
              (CaseArm
                left:<Lit_Chars --version>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --version>)
                    (w <Lit_Chars --help>)
                    (w <Lit_Chars --port>)
                    (w <Lit_Chars --passwd>)
                    (w <Lit_Chars --wait>)
                    (w
                      <Lit_Chars ->
                      (${ VSub_Name noargopts)
                      <Lit_LBracket "[">
                      <Lit_Chars Vpw>
                      <Lit_RBracket "]">
                    )
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --host>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --host>)
                    (w <Lit_Chars --ipaddr>)
                    (w
                      <Lit_Chars ->
                      (${ VSub_Name noargopts)
                      <Lit_LBracket "[">
                      <Lit_Chars hi>
                      <Lit_RBracket "]">
                    )
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars local>)
                    (w
                      <Lit_VarLike "PATH=">
                      ($ PATH)
                      <Lit_Colon ":">
                      <Lit_Slash />
                      <Lit_Chars sbin>
                    )
                  )
                  (C
                    (w <Lit_Chars _comp_compgen_split>)
                    (w <Lit_Chars -->)
                    (w
                      (DQ
                        (CommandSub
                          left_token:<Left_DollarParen "$(">
                          child:(command.Pipeline
                            children:[
                              (command.Redirect
                                child:(BraceGroup
                                  left:<Lit_LBrace "{">
                                  children:[
                                    (command.AndOr
                                      children:[
                                        (C
                                          (w <Lit_Chars ip>)
                                          (w
                                            <Lit_Chars -c>
                                            <Lit_Equals "=">
                                            <Lit_Chars never>
                                          )
                                          (w <Lit_Chars addr>)
                                          (w <Lit_Chars show>)
                                        )
                                        (C
                                          (w <Lit_Chars ip>)
                                          (w <Lit_Chars addr>)
                                          (w <Lit_Chars show>)
                                        )
                                        (C
                                          (w <Lit_Chars ifconfig>)
                                          (w <Lit_Chars -a>)
                                        )
                                      ]
                                      ops:[<Op_DPipe "||"> <Op_DPipe "||">]
                                    )
                                  ]
                                  right:<Lit_RBrace "}">
                                )
                                redirects:[
                                  (Redir
                                    op:<Redir_Great ">">
                                    loc:(redir_loc.Fd fd:2)
                                    arg:(w
                                      <Lit_Slash />
                                      <Lit_Chars dev>
                                      <Lit_Slash />
                                      <Lit_Chars "null">
                                    )
                                  )
                                ]
                              )
                              (C
                                (w <Lit_Chars command>)
                                (w <Lit_Chars sed>)
                                (w <Lit_Chars -ne>)
                                (w
                                  (SQ
                                    "s/.*[[:space:]]Bcast:\\([^[:space:]]*\\).*/\\1/p"
                                  )
                                )
                                (w <Lit_Chars -ne>)
                                (w
                                  (SQ
                                    "s/.*inet.*[[:space:]]brd[[:space:]]\\([^[:space:]]*\\).*/\\1/p"
                                  )
                                )
                                (w <Lit_Chars -ne>)
                                (w
                                  (SQ
                                    "s/.*[[:space:]]broadcast[[:space:]]\\{1,\\}\\([^[:space:]]*\\).*/\\1/p"
                                  )
                                )
                              )
                            ]
                            ops:[<Op_Pipe "|">]
                          )
                          right:<Eof_RParen ")">
                        )
                      )
                    )
                  )
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -a>)
                    (w <Lit_Chars known_hosts>)
                    (w <Lit_Chars -->)
                    (w (DQ ($ cur)))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --file>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --file>)
                    (w <Lit_Chars -> (${ VSub_Name noargopts) <Lit_Chars f>)
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (C (w <Lit_Chars _comp_compgen_filedir>))
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
            ]
            arms_end:<KW_Esac esac>
          )
          (command.AndOr
            children:[
              (command.DBracket
                left:<KW_DLeftBracket "[[">
                expr:(bool_expr.WordTest w:(w ($ was_split)))
                right:<Lit_DRightBracket "]]">
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DAmp "&&">]
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x1e8a
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.Binary
                        op_id:BoolBinary_GlobDEqual
                        left:(w ($ cur))
                        right:(w <Lit_Chars -> <Lit_Other "*">)
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (C (w <Lit_Chars _comp_compgen_help>))
                  (command.AndOr
                    children:[
                      (command.DBracket
                        left:<KW_DLeftBracket "[[">
                        expr:(bool_expr.Binary
                          op_id:BoolBinary_GlobDEqual
                          left:(w
                            (BracedVarSub
                              left:<Left_DollarBrace "${">
                              name_tok:<VSub_Name COMPREPLY>
                              var_name:COMPREPLY
                              suffix_op:(suffix_op.Unary
                                op:<VTest_Hyphen ->
                                arg_word:(w)
                              )
                              right:<Right_DollarBrace "}">
                            )
                          )
                          right:(w <Lit_Other "*"> <BoolBinary_GlobEqual "=">)
                        )
                        right:<Lit_DRightBracket "]]">
                      )
                      (C
                        (w <Lit_Chars compopt>)
                        (w <Lit_Chars -o>)
                        (w <Lit_Chars nospace>)
                      )
                    ]
                    ops:[<Op_DAmp "&&">]
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                then_tok:...0x1e1e
              )
            ]
            else_action:[]
            fi_kw:<KW_Fi fi>
          )
          (C (w <Lit_Chars _comp_compgen_mac_addresses>))
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_wol()\n{\n    local cur prev words cword was_split comp_args\n    _comp_initialize -s -n : -- \"$@\" || return\n\n    local noargopts='!(-*|*[pwhif]*)'\n    # shellcheck disable=SC2254\n    case $prev in\n        --version | --help | --port | --passwd | --wait | -${noargopts}[Vpw])\n            return\n            ;;\n        --host | --ipaddr | -${noargopts}[hi])\n            # Broadcast addresses\n            local PATH=$PATH:/sbin\n            _comp_compgen_split -- \"$({\n                ip -c=never addr show || ip addr show || ifconfig -a\n            } 2>/dev/null |\n                command sed \\\n                    -ne 's/.*[[:space:]]Bcast:\\([^[:space:]]*\\).*/\\1/p' \\\n                    -ne 's/.*inet.*[[:space:]]brd[[:space:]]\\([^[:space:]]*\\).*/\\1/p' \\\n                    -ne 's/.*[[:space:]]broadcast[[:space:]]\\{1,\\}\\([^[:space:]]*\\).*/\\1/p')\"\n            _comp_compgen -a known_hosts -- \"$cur\"\n            return\n            ;;\n        --file | -${noargopts}f)\n            _comp_compgen_filedir\n            return\n            ;;\n    esac\n\n    [[ $was_split ]] && return\n\n    if [[ $cur == -* ]]; then\n        _comp_compgen_help\n        [[ ${COMPREPLY-} == *= ]] && compopt -o nospace\n        return\n    fi\n\n    _comp_compgen_mac_addresses\n}"
    )
    (C
      (w <Lit_Chars complete>)
      (w <Lit_Chars -F>)
      (w <Lit_Chars _comp_cmd_wol>)
      (w <Lit_Chars wol>)
    )
  ]
  ops:[<Op_DAmp "&&">]
)
(C (w <Lit_Chars complete>) (w <Lit_Chars -u>) (w <Lit_Chars write>))
(command.AndOr
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_wsimport>
      name:_comp_cmd_wsimport
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars cur>)
            (w <Lit_Chars prev>)
            (w <Lit_Chars words>)
            (w <Lit_Chars cword>)
            (w <Lit_Chars comp_args>)
          )
          (command.AndOr
            children:[
              (C
                (w <Lit_Chars _comp_initialize>)
                (w <Lit_Chars -n>)
                (w <Lit_Colon ":">)
                (w <Lit_Chars -->)
                (w (DQ ($ VSub_At)))
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DPipe "||">]
          )
          (command.Case
            case_kw:<KW_Case case>
            to_match:(case_arg.Word w:(w ($ prev)))
            arms_start:<KW_In in>
            arms:[
              (CaseArm
                left:<Lit_Chars -help>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars -help>)
                    (w <Lit_Chars -version>)
                    (w <Lit_Chars -B>)
                    (w <Lit_Chars -p>)
                    (w <Lit_Chars -wsdllocation>)
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars -b>
                pattern:(pat.Words words:[(w <Lit_Chars -b>)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen_filedir>)
                    (w (SQ "@(xml|xjb)"))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars -catalog>
                pattern:(pat.Words words:[(w <Lit_Chars -catalog>)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen_filedir>)
                    (w (SQ "@(xml|soc|catalog)"))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars -d>
                pattern:(pat.Words
                  words:[(w <Lit_Chars -d>) (w <Lit_Chars "–s">)]
                )
                middle:<Right_CasePat ")">
                action:[
                  (C (w <Lit_Chars _comp_compgen_filedir>) (w <Lit_Chars -d>))
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars -target>
                pattern:(pat.Words words:[(w <Lit_Chars -target>)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ "2.0 2.1 2.2"))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars -clientjar>
                pattern:(pat.Words words:[(w <Lit_Chars -clientjar>)])
                middle:<Right_CasePat ")">
                action:[
                  (C (w <Lit_Chars _comp_compgen_filedir>) (w <Lit_Chars jar>))
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
            ]
            arms_end:<KW_Esac esac>
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x1632
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.Binary
                        op_id:BoolBinary_GlobDEqual
                        left:(w ($ cur))
                        right:(w
                          <Lit_Chars -httpproxy>
                          <Lit_Colon ":">
                          <Lit_Other "*">
                        )
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen_known_hosts>)
                    (w <Lit_Chars -->)
                    (w
                      (DQ
                        (BracedVarSub
                          left:<Left_DollarBrace "${">
                          name_tok:<VSub_Name cur>
                          var_name:cur
                          suffix_op:(suffix_op.Unary
                            op:<VOp1_Pound "#">
                            arg_word:(w <Lit_Chars "-httpproxy:">)
                          )
                          right:<Right_DollarBrace "}">
                        )
                      )
                    )
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                then_tok:...0x15c2
              )
              (IfArm
                keyword:<KW_Elif elif>
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.Binary
                        op_id:BoolBinary_GlobDEqual
                        left:(w ($ cur))
                        right:(w <Lit_Chars -> <Lit_Other "*">)
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen_help>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -help>)
                  )
                  (command.AndOr
                    children:[
                      (command.DBracket
                        left:<KW_DLeftBracket "[[">
                        expr:(bool_expr.Binary
                          op_id:BoolBinary_GlobDEqual
                          left:(w
                            (BracedVarSub
                              left:<Left_DollarBrace "${">
                              name_tok:<VSub_Name COMPREPLY>
                              var_name:COMPREPLY
                              suffix_op:(suffix_op.Unary
                                op:<VTest_Hyphen ->
                                arg_word:(w)
                              )
                              right:<Right_DollarBrace "}">
                            )
                          )
                          right:(w <Lit_Other "*"> <Lit_Colon ":">)
                        )
                        right:<Lit_DRightBracket "]]">
                      )
                      (C
                        (w <Lit_Chars compopt>)
                        (w <Lit_Chars -o>)
                        (w <Lit_Chars nospace>)
                      )
                    ]
                    ops:[<Op_DAmp "&&">]
                  )
                  (C
                    (w <Lit_Chars _comp_ltrim_colon_completions>)
                    (w (DQ ($ cur)))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                then_tok:...0x1f3e
              )
            ]
            else_action:[]
            fi_kw:<KW_Fi fi>
          )
          (C (w <Lit_Chars _comp_compgen_filedir>) (w <Lit_Chars wsdl>))
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_wsimport()\n{\n    local cur prev words cword comp_args\n    _comp_initialize -n : -- \"$@\" || return\n\n    case $prev in\n        -help | -version | -B | -p | -wsdllocation)\n            return\n            ;;\n        -b)\n            _comp_compgen_filedir '@(xml|xjb)'\n            return\n            ;;\n        -catalog)\n            _comp_compgen_filedir '@(xml|soc|catalog)'\n            return\n            ;;\n        -d | –s)\n            _comp_compgen_filedir -d\n            return\n            ;;\n        -target)\n            _comp_compgen -- -W '2.0 2.1 2.2'\n            return\n            ;;\n        -clientjar)\n            _comp_compgen_filedir jar\n            return\n            ;;\n    esac\n\n    if [[ $cur == -httpproxy:* ]]; then\n        _comp_compgen_known_hosts -- \"${cur#-httpproxy:}\"\n        return\n    elif [[ $cur == -* ]]; then\n        _comp_compgen_help -- -help\n        [[ ${COMPREPLY-} == *: ]] && compopt -o nospace\n        _comp_ltrim_colon_completions \"$cur\"\n        return\n    fi\n\n    _comp_compgen_filedir wsdl\n}"
    )
    (C
      (w <Lit_Chars complete>)
      (w <Lit_Chars -F>)
      (w <Lit_Chars _comp_cmd_wsimport>)
      (w <Lit_Chars wsimport>)
    )
  ]
  ops:[<Op_DAmp "&&">]
)
(command.AndOr
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_wtf>
      name:_comp_cmd_wtf
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars cur>)
            (w <Lit_Chars prev>)
            (w <Lit_Chars words>)
            (w <Lit_Chars cword>)
            (w <Lit_Chars comp_args>)
            (w <Lit_Chars addf>)
          )
          (command.AndOr
            children:[
              (C
                (w <Lit_Chars _comp_initialize>)
                (w <Lit_Chars -->)
                (w (DQ ($ VSub_At)))
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DPipe "||">]
          )
          (command.AndOr
            children:[
              (command.DBracket
                left:<KW_DLeftBracket "[[">
                expr:(bool_expr.Binary
                  op_id:BoolBinary_GlobDEqual
                  left:(w ($ prev))
                  right:(w <BoolUnary_f -f>)
                )
                right:<Lit_DRightBracket "]]">
              )
              (C (w <Lit_Chars _comp_compgen_filedir>))
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DAmp "&&"> <Op_DAmp "&&">]
          )
          (command.AndOr
            children:[
              (command.DBracket
                left:<KW_DLeftBracket "[[">
                expr:(bool_expr.Binary
                  op_id:BoolBinary_GlobDEqual
                  left:(w
                    (BracedVarSub
                      left:<Left_DollarBrace "${">
                      name_tok:<VSub_Name words>
                      var_name:words
                      bracket_op:(bracket_op.WholeArray op_id:Arith_Star)
                      right:<Right_DollarBrace "}">
                    )
                  )
                  right:(w
                    <Lit_Other "*">
                    (word_part.EscapedLiteral
                      token:<Lit_EscapedChar "\\ ">
                      ch:" "
                    )
                    <BoolUnary_f -f>
                    <Lit_Other "*">
                  )
                )
                right:<Lit_DRightBracket "]]">
              )
              (command.ShAssignment
                left:<Lit_VarLike "addf=">
                pairs:[
                  (AssignPair
                    left:...0x19ee
                    lhs:(sh_lhs.Name left:...0x19ee name:addf)
                    op:assign_op.Equal
                    rhs:(rhs_word.Empty)
                  )
                ]
              )
              (command.ShAssignment
                left:<Lit_VarLike "addf=">
                pairs:[
                  (AssignPair
                    left:...0x19be
                    lhs:(sh_lhs.Name left:...0x19be name:addf)
                    op:assign_op.Equal
                    rhs:(w <Lit_Chars -f>)
                  )
                ]
              )
            ]
            ops:[<Op_DAmp "&&"> <Op_DPipe "||">]
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x1982
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.Binary
                        op_id:BoolBinary_GlobDEqual
                        left:(w ($ cur))
                        right:(w <Lit_Chars -> <Lit_Other "*">)
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (command.ShAssignment
                    left:<Lit_VarLike "COMPREPLY=">
                    pairs:[
                      (AssignPair
                        left:...0x18fa
                        lhs:(sh_lhs.Name left:...0x18fa name:COMPREPLY)
                        op:assign_op.Equal
                        rhs:(w
                          (word_part.InitializerLiteral
                            left:<Op_LParen "(">
                            pairs:[
                              (InitializerWord.ArrayWord
                                w:(w
                                  (BracedVarSub
                                    left:<Left_DollarBrace "${">
                                    name_tok:<VSub_Name addf>
                                    var_name:addf
                                    suffix_op:(suffix_op.Unary
                                      op:<VTest_ColonPlus ":+">
                                      arg_word:(w (DQ ($ addf)))
                                    )
                                    right:<Right_DollarBrace "}">
                                  )
                                )
                              )
                            ]
                            right:<Right_Initializer ")">
                          )
                        )
                      )
                    ]
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                then_tok:...0x1916
              )
            ]
            else_action:[]
            fi_kw:<KW_Fi fi>
          )
          (C
            (w <Lit_Chars local>)
            (w <Lit_VarLike "db="> (DQ))
            (w <Lit_VarLike "has_db="> (DQ))
          )
          (C
            (w <Lit_Chars set>)
            (w <Lit_Chars -->)
            (w
              (DQ
                (BracedVarSub
                  left:<Left_DollarBrace "${">
                  name_tok:<VSub_Name words>
                  var_name:words
                  bracket_op:(bracket_op.WholeArray op_id:Lit_At)
                  right:<Right_DollarBrace "}">
                )
              )
            )
          )
          (command.WhileUntil
            keyword:<KW_While while>
            cond:[
              (command.Sentence
                child:(command.DParen
                  left:<Op_DLeftParen "((">
                  child:(arith_expr.Binary
                    op:<Arith_Great ">">
                    left:(w ($ VSub_Pound))
                    right:(w <Lit_Digits 0>)
                  )
                  right:<Op_DRightParen ")">
                )
                terminator:<Op_Semi ";">
              )
            ]
            body:(command.DoGroup
              left:<KW_Do do>
              children:[
                (command.If
                  if_kw:<KW_If if>
                  arms:[
                    (IfArm
                      keyword:...0x16d6
                      cond:[
                        (command.Sentence
                          child:(command.DBracket
                            left:<KW_DLeftBracket "[[">
                            expr:(bool_expr.Binary
                              op_id:BoolBinary_GlobDEqual
                              left:(w ($ 1))
                              right:(w <BoolUnary_f -f>)
                            )
                            right:<Lit_DRightBracket "]]">
                          )
                          terminator:<Op_Semi ";">
                        )
                      ]
                      then_kw:<KW_Then then>
                      action:[
                        (C (w <Lit_Chars shift>))
                        (command.If
                          if_kw:<KW_If if>
                          arms:[
                            (IfArm
                              keyword:...0x161e
                              cond:[
                                (command.Sentence
                                  child:(command.DParen
                                    left:<Op_DLeftParen "((">
                                    child:(arith_expr.Binary
                                      op:<Arith_Great ">">
                                      left:(w ($ VSub_Pound))
                                      right:(w <Lit_Digits 0>)
                                    )
                                    right:<Op_DRightParen ")">
                                  )
                                  terminator:<Op_Semi ";">
                                )
                              ]
                              then_kw:<KW_Then then>
                              action:[
                                (command.ShAssignment
                                  left:<Lit_VarLike "db=">
                                  pairs:[
                                    (AssignPair
                                      left:...0x15aa
                                      lhs:(sh_lhs.Name left:...0x15aa name:db)
                                      op:assign_op.Equal
                                      rhs:(w ($ 1))
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  left:<Lit_VarLike "has_db=">
                                  pairs:[
                                    (AssignPair
                                      left:...0x156e
                                      lhs:(sh_lhs.Name
                                        left:...0x156e
                                        name:has_db
                                      )
                                      op:assign_op.Equal
                                      rhs:(w <Lit_Chars set>)
                                    )
                                  ]
                                )
                              ]
                              then_tok:...0x15ca
                            )
                          ]
                          else_action:[]
                          fi_kw:<KW_Fi fi>
                        )
                        (command.ControlFlow keyword:<ControlFlow_Break break>)
                      ]
                      then_tok:...0x166e
                    )
                  ]
                  else_action:[]
                  fi_kw:<KW_Fi fi>
                )
                (C (w <Lit_Chars shift>))
              ]
              right:<KW_Done done>
            )
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x1efe
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.LogicalNot
                        child:(bool_expr.WordTest w:(w ($ has_db)))
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (C (w <Lit_Chars local>) (w <Lit_Chars f>))
                  (command.ForEach
                    keyword:<KW_For for>
                    iter_names:[f]
                    iterable:(for_iter.Words
                      words:[
                        (w
                          (DQ
                            (BracedVarSub
                              left:<Left_DollarBrace "${">
                              name_tok:<VSub_Name ACRONYMDB>
                              var_name:ACRONYMDB
                              suffix_op:(suffix_op.Unary
                                op:<VTest_Hyphen ->
                                arg_word:(rhs_word.Empty)
                              )
                              right:<Right_DollarBrace "}">
                            )
                          )
                        )
                        (w
                          <Lit_Slash />
                          <Lit_Chars usr>
                          <Lit_Slash />
                          <Lit_Chars share>
                          <Lit_Slash />
                          <Lit_Chars misc>
                          <Lit_Slash />
                          <Lit_Chars acronyms>
                        )
                        (w
                          <Lit_Slash />
                          <Lit_Chars usr>
                          <Lit_Slash />
                          <Lit_Chars share>
                          <Lit_Slash />
                          <Lit_Chars games>
                          <Lit_Slash />
                          <Lit_Chars bsdgames>
                          <Lit_Slash />
                          <Lit_Chars acronyms>
                        )
                      ]
                    )
                    semi_tok:<Op_Semi ";">
                    body:(command.DoGroup
                      left:<KW_Do do>
                      children:[
                        (command.AndOr
                          children:[
                            (command.DBracket
                              left:<KW_DLeftBracket "[[">
                              expr:(bool_expr.Unary
                                op_id:BoolUnary_f
                                child:(w ($ f))
                              )
                              right:<Lit_DRightBracket "]]">
                            )
                            (command.ShAssignment
                              left:<Lit_VarLike "db=">
                              pairs:[
                                (AssignPair
                                  left:...0x1d06
                                  lhs:(sh_lhs.Name left:...0x1d06 name:db)
                                  op:assign_op.Equal
                                  rhs:(w (DQ ($ f)))
                                )
                                (AssignPair
                                  left:<Lit_VarLike "has_db=">
                                  lhs:(sh_lhs.Name left:...0x1cde name:has_db)
                                  op:assign_op.Equal
                                  rhs:(w <Lit_Chars set>)
                                )
                              ]
                            )
                            (command.ControlFlow
                              keyword:<ControlFlow_Break break>
                            )
                          ]
                          ops:[<Op_DAmp "&&"> <Op_DAmp "&&">]
                        )
                      ]
                      right:<KW_Done done>
                    )
                  )
                  (command.AndOr
                    children:[
                      (command.DBracket
                        left:<KW_DLeftBracket "[[">
                        expr:(bool_expr.WordTest w:(w ($ has_db)))
                        right:<Lit_DRightBracket "]]">
                      )
                      (command.ControlFlow keyword:<ControlFlow_Return return>)
                    ]
                    ops:[<Op_DPipe "||">]
                  )
                ]
                then_tok:...0x1ea6
              )
            ]
            else_action:[]
            fi_kw:<KW_Fi fi>
          )
          (C
            (w <Lit_Chars _comp_compgen>)
            (w <Lit_Chars -c>)
            (w
              (DQ
                (BracedVarSub
                  left:<Left_DollarBrace "${">
                  name_tok:<VSub_Name cur>
                  var_name:cur
                  suffix_op:(suffix_op.Unary op:<VOp1_DCaret "^^"> arg_word:(w))
                  right:<Right_DollarBrace "}">
                )
              )
            )
            (w <Lit_Chars split>)
            (w <Lit_Chars -->)
            (w
              (DQ
                (CommandSub
                  left_token:<Left_DollarParen "$(">
                  child:(C
                    (w <Lit_Chars cut>)
                    (w <Lit_Chars -f>)
                    (w <Lit_Number 1>)
                    (w <Lit_Chars -s>)
                    (w (DQ ($ db)) <Lit_Star "*">)
                  )
                  right:<Eof_RParen ")">
                )
                <Lit_Chars " ">
                ($ addf)
              )
            )
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_wtf()\n{\n    local cur prev words cword comp_args addf\n    _comp_initialize -- \"$@\" || return\n\n    [[ $prev == -f ]] && _comp_compgen_filedir && return\n    [[ ${words[*]} == *\\ -f* ]] && addf= || addf=-f\n    if [[ $cur == -* ]]; then\n        COMPREPLY=(${addf:+\"$addf\"})\n        return\n    fi\n\n    local db=\"\" has_db=\"\"\n\n    set -- \"${words[@]}\"\n    while (($# > 0)); do\n        if [[ $1 == -f ]]; then\n            shift\n            if (($# > 0)); then\n                db=$1\n                has_db=set\n            fi\n            break\n        fi\n        shift\n    done\n\n    if [[ ! $has_db ]]; then\n        local f\n        for f in \"${ACRONYMDB-}\" /usr/share/misc/acronyms \\\n            /usr/share/games/bsdgames/acronyms; do\n            [[ -f $f ]] && db=\"$f\" has_db=set && break\n        done\n        [[ $has_db ]] || return\n    fi\n\n    _comp_compgen -c \"${cur^^}\" split \\\n        -- \"$(cut -f 1 -s \"$db\"* 2>/dev/null) $addf\"\n}"
    )
    (C
      (w <Lit_Chars complete>)
      (w <Lit_Chars -F>)
      (w <Lit_Chars _comp_cmd_wtf>)
      (w <Lit_Chars wtf>)
    )
  ]
  ops:[<Op_DAmp "&&">]
)
(command.AndOr
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_wvdial>
      name:_comp_cmd_wvdial
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars cur>)
            (w <Lit_Chars prev>)
            (w <Lit_Chars words>)
            (w <Lit_Chars cword>)
            (w <Lit_Chars was_split>)
            (w <Lit_Chars comp_args>)
          )
          (command.AndOr
            children:[
              (C
                (w <Lit_Chars _comp_initialize>)
                (w <Lit_Chars -s>)
                (w <Lit_Chars -->)
                (w (DQ ($ VSub_At)))
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DPipe "||">]
          )
          (command.Case
            case_kw:<KW_Case case>
            to_match:(case_arg.Word w:(w ($ prev)))
            arms_start:<KW_In in>
            arms:[
              (CaseArm
                left:<Lit_Chars --config>
                pattern:(pat.Words words:[(w <Lit_Chars --config>)])
                middle:<Right_CasePat ")">
                action:[
                  (C (w <Lit_Chars _comp_compgen_filedir>))
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
            ]
            arms_end:<KW_Esac esac>
          )
          (command.AndOr
            children:[
              (command.DBracket
                left:<KW_DLeftBracket "[[">
                expr:(bool_expr.WordTest w:(w ($ was_split)))
                right:<Lit_DRightBracket "]]">
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DAmp "&&">]
          )
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars config>)
            (w <Lit_Chars i>)
            (w
              <Lit_VarLike "IFS=">
              (SingleQuoted
                left:<Left_DollarSingleQuote "$'">
                sval:"\n"
                right:<Right_SingleQuote "'">
              )
            )
          )
          (command.Case
            case_kw:<KW_Case case>
            to_match:(case_arg.Word w:(w ($ cur)))
            arms_start:<KW_In in>
            arms:[
              (CaseArm
                left:<Lit_Chars ->
                pattern:(pat.Words words:[(w <Lit_Chars -> <Lit_Star "*">)])
                middle:<Right_CasePat ")">
                action:[
                  (C (w <Lit_Chars _comp_compgen_help>))
                  (command.AndOr
                    children:[
                      (command.DBracket
                        left:<KW_DLeftBracket "[[">
                        expr:(bool_expr.Binary
                          op_id:BoolBinary_GlobDEqual
                          left:(w
                            (BracedVarSub
                              left:<Left_DollarBrace "${">
                              name_tok:<VSub_Name COMPREPLY>
                              var_name:COMPREPLY
                              suffix_op:(suffix_op.Unary
                                op:<VTest_Hyphen ->
                                arg_word:(w)
                              )
                              right:<Right_DollarBrace "}">
                            )
                          )
                          right:(w <Lit_Other "*"> <BoolBinary_GlobEqual "=">)
                        )
                        right:<Lit_DRightBracket "]]">
                      )
                      (C
                        (w <Lit_Chars compopt>)
                        (w <Lit_Chars -o>)
                        (w <Lit_Chars nospace>)
                      )
                    ]
                    ops:[<Op_DAmp "&&">]
                  )
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Star "*">
                pattern:(pat.Words words:[(w <Lit_Star "*">)])
                middle:<Right_CasePat ")">
                action:[
                  (command.ShAssignment
                    left:<Lit_VarLike "config=">
                    pairs:[
                      (AssignPair
                        left:...0x1792
                        lhs:(sh_lhs.Name left:...0x1792 name:config)
                        op:assign_op.Equal
                        rhs:(w
                          (DQ <Lit_Chars /etc/wvdial.conf>)
                          (SingleQuoted
                            left:<Left_DollarSingleQuote "$'">
                            sval:"\n"
                            right:<Right_SingleQuote "'">
                          )
                          (DQ ($ HOME) <Lit_Chars /.wvdialrc>)
                        )
                      )
                    ]
                  )
                  (command.ForExpr
                    keyword:<KW_For for>
                    init:(arith_expr.BinaryAssign
                      op_id:Arith_Equal
                      left:<Lit_ArithVarLike i>
                      right:(w <Lit_Digits 1>)
                    )
                    cond:(arith_expr.Binary
                      op:<Arith_Less "<">
                      left:<Lit_ArithVarLike i>
                      right:<Lit_ArithVarLike cword>
                    )
                    update:(arith_expr.UnaryAssign
                      op_id:Node_PostDPlus
                      child:<Lit_ArithVarLike i>
                    )
                    body:(command.DoGroup
                      left:<KW_Do do>
                      children:[
                        (command.If
                          if_kw:<KW_If if>
                          arms:[
                            (IfArm
                              keyword:...0x165a
                              cond:[
                                (command.Sentence
                                  child:(command.DBracket
                                    left:<KW_DLeftBracket "[[">
                                    expr:(bool_expr.Binary
                                      op_id:BoolBinary_GlobDEqual
                                      left:(w
                                        (BracedVarSub
                                          left:<Left_DollarBrace "${">
                                          name_tok:<VSub_Name words>
                                          var_name:words
                                          bracket_op:(bracket_op.ArrayIndex
                                            expr:<Lit_ArithVarLike i>
                                          )
                                          right:<Right_DollarBrace "}">
                                        )
                                      )
                                      right:(w (DQ <Lit_Chars --config>))
                                    )
                                    right:<Lit_DRightBracket "]]">
                                  )
                                  terminator:<Op_Semi ";">
                                )
                              ]
                              then_kw:<KW_Then then>
                              action:[
                                (command.ShAssignment
                                  left:<Lit_VarLike "config=">
                                  pairs:[
                                    (AssignPair
                                      left:...0x15ae
                                      lhs:(sh_lhs.Name
                                        left:...0x15ae
                                        name:config
                                      )
                                      op:assign_op.Equal
                                      rhs:(w
                                        (BracedVarSub
                                          left:<Left_DollarBrace "${">
                                          name_tok:<VSub_Name words>
                                          var_name:words
                                          bracket_op:(bracket_op.ArrayIndex
                                            expr:(arith_expr.Binary
                                              op:<Arith_Plus "+">
                                              left:<Lit_ArithVarLike i>
                                              right:(w <Lit_Digits 1>)
                                            )
                                          )
                                          right:<Right_DollarBrace "}">
                                        )
                                      )
                                    )
                                  ]
                                )
                                (command.ControlFlow
                                  keyword:<ControlFlow_Break break>
                                )
                              ]
                              then_tok:...0x15ca
                            )
                          ]
                          else_action:[]
                          fi_kw:<KW_Fi fi>
                        )
                      ]
                      right:<KW_Done done>
                    )
                  )
                  (C
                    (w <Lit_Chars _comp_compgen_split>)
                    (w <Lit_Chars -l>)
                    (w <Lit_Chars -X>)
                    (w (SQ Defaults))
                    (w <Lit_Chars -->)
                    (w
                      (DQ
                        (CommandSub
                          left_token:<Left_DollarParen "$(">
                          child:(C
                            (w <Lit_Chars command>)
                            (w <Lit_Chars sed>)
                            (w <Lit_Chars -ne>)
                            (w (SQ "s/^\\[Dialer \\(.*\\)\\]$/\\1/p"))
                            (w (DQ ($ config)))
                          )
                          right:<Eof_RParen ")">
                        )
                      )
                    )
                  )
                  (command.ShAssignment
                    left:<Lit_VarLike "COMPREPLY=">
                    pairs:[
                      (AssignPair
                        left:...0x1dca
                        lhs:(sh_lhs.Name left:...0x1dca name:COMPREPLY)
                        op:assign_op.Equal
                        rhs:(w
                          (word_part.InitializerLiteral
                            left:<Op_LParen "(">
                            pairs:[
                              (InitializerWord.ArrayWord
                                w:(w
                                  (DQ
                                    (BracedVarSub
                                      left:<Left_DollarBrace "${">
                                      name_tok:<VSub_Name COMPREPLY>
                                      var_name:COMPREPLY
                                      bracket_op:(bracket_op.WholeArray
                                        op_id:Lit_At
                                      )
                                      suffix_op:(suffix_op.PatSub
                                        pat:(w <Lit_Chars " ">)
                                        replace:(w
                                          (word_part.EscapedLiteral
                                            token:<Lit_EscapedChar "\\\\">
                                            ch:"\\"
                                          )
                                          <Lit_Chars " ">
                                        )
                                        replace_mode:Lit_Slash
                                        slash_tok:<VOp2_Slash />
                                      )
                                      right:<Right_DollarBrace "}">
                                    )
                                  )
                                )
                              )
                            ]
                            right:<Right_Initializer ")">
                          )
                        )
                      )
                    ]
                  )
                ]
                right:<Op_DSemi ";;">
              )
            ]
            arms_end:<KW_Esac esac>
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_wvdial()\n{\n    local cur prev words cword was_split comp_args\n    _comp_initialize -s -- \"$@\" || return\n\n    case $prev in\n        --config)\n            _comp_compgen_filedir\n            return\n            ;;\n    esac\n\n    [[ $was_split ]] && return\n\n    local config i IFS=$'\\n'\n\n    case $cur in\n        -*)\n            _comp_compgen_help\n            [[ ${COMPREPLY-} == *= ]] && compopt -o nospace\n            ;;\n        *)\n            # start with global and personal config files\n            config=\"/etc/wvdial.conf\"$'\\n'\"$HOME/.wvdialrc\"\n            # replace with command line config file if present\n            for ((i = 1; i < cword; i++)); do\n                if [[ ${words[i]} == \"--config\" ]]; then\n                    config=${words[i + 1]}\n                    break\n                fi\n            done\n            # parse config files for sections and\n            # remove default section\n            _comp_compgen_split -l -X 'Defaults' -- \"$(command sed -ne \\\n                's/^\\[Dialer \\(.*\\)\\]$/\\1/p' \"$config\" 2>/dev/null)\"\n            # escape spaces\n            COMPREPLY=(\"${COMPREPLY[@]// /\\\\ }\")\n            ;;\n    esac\n\n}"
    )
    (C
      (w <Lit_Chars complete>)
      (w <Lit_Chars -F>)
      (w <Lit_Chars _comp_cmd_wvdial>)
      (w <Lit_Chars wvdial>)
    )
  ]
  ops:[<Op_DAmp "&&">]
)
(command.CommandList
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_xdg_mime__mimetype>
      name:_comp_cmd_xdg_mime__mimetype
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C (w <Lit_Chars local>) (w <Lit_Chars d>) (w <Lit_Chars i>))
          (C (w <Lit_Chars local>) (w <Lit_Chars -a>) (w <Lit_Chars arr>))
          (command.ForEach
            keyword:<KW_For for>
            iter_names:[d]
            iterable:(for_iter.Words
              words:[
                (w
                  <Lit_Slash />
                  <Lit_Chars usr>
                  <Lit_Slash />
                  <Lit_Chars share>
                  <Lit_Slash />
                  <Lit_Chars mime>
                )
                (w
                  <Lit_Slash />
                  <Lit_Chars usr>
                  <Lit_Slash />
                  <Lit_Chars local>
                  <Lit_Slash />
                  <Lit_Chars share>
                  <Lit_Slash />
                  <Lit_Chars mime>
                )
              ]
            )
            semi_tok:<Op_Semi ";">
            body:(command.DoGroup
              left:<KW_Do do>
              children:[
                (command.AndOr
                  children:[
                    (C
                      (w <Lit_Chars _comp_compgen>)
                      (w <Lit_Chars -v>)
                      (w <Lit_Chars arr>)
                      (w <Lit_Chars -C>)
                      (w (DQ ($ d)))
                      (w <Lit_Chars -->)
                      (w <Lit_Chars -f>)
                      (w <Lit_Chars -o>)
                      (w <Lit_Chars plusdirs>)
                      (w <Lit_Chars -X>)
                      (w (DQ <Lit_Chars "!*.xml">))
                    )
                    (command.ControlFlow
                      keyword:<ControlFlow_Continue continue>
                    )
                  ]
                  ops:[<Op_DPipe "||">]
                )
                (command.ForEach
                  keyword:<KW_For for>
                  iter_names:[i]
                  iterable:(for_iter.Words
                    words:[
                      (w
                        (DQ
                          (BracedVarSub
                            left:<Left_DollarBrace "${">
                            name_tok:<VSub_Name arr>
                            var_name:arr
                            prefix_op:<VSub_Bang "!">
                            bracket_op:(bracket_op.WholeArray op_id:Lit_At)
                            right:<Right_DollarBrace "}">
                          )
                        )
                      )
                    ]
                  )
                  semi_tok:<Op_Semi ";">
                  body:(command.DoGroup
                    left:<KW_Do do>
                    children:[
                      (command.Case
                        case_kw:<KW_Case case>
                        to_match:(case_arg.Word
                          w:(w
                            (BracedVarSub
                              left:<Left_DollarBrace "${">
                              name_tok:<VSub_Name arr>
                              var_name:arr
                              bracket_op:(bracket_op.ArrayIndex
                                expr:<Lit_ArithVarLike i>
                              )
                              right:<Right_DollarBrace "}">
                            )
                          )
                        )
                        arms_start:<KW_In in>
                        arms:[
                          (CaseArm
                            left:<Lit_Chars packages>
                            pattern:(pat.Words
                              words:[(w <Lit_Chars packages> <Lit_Star "*">)]
                            )
                            middle:<Right_CasePat ")">
                            action:[
                              (C
                                (w <Lit_Chars unset>)
                                (w <Lit_Chars -v>)
                                (w (DQ <Lit_Chars "arr[i]">))
                              )
                            ]
                            right:<Op_DSemi ";;">
                          )
                          (CaseArm
                            left:<Lit_Star "*">
                            pattern:(pat.Words
                              words:[(w <Lit_Star "*"> <Lit_Chars .xml>)]
                            )
                            middle:<Right_CasePat ")">
                            action:[
                              (command.ShAssignment
                                left:<Lit_ArrayLhsOpen "arr[">
                                pairs:[
                                  (AssignPair
                                    left:...0x187a
                                    lhs:(sh_lhs.IndexedName
                                      left:...0x187a
                                      name:arr
                                      index:<Lit_ArithVarLike i>
                                    )
                                    op:assign_op.Equal
                                    rhs:(w
                                      (BracedVarSub
                                        left:<Left_DollarBrace "${">
                                        name_tok:<VSub_Name arr>
                                        var_name:arr
                                        bracket_op:(bracket_op.ArrayIndex
                                          expr:<Lit_ArithVarLike i>
                                        )
                                        suffix_op:(suffix_op.Unary
                                          op:<VOp1_Percent "%">
                                          arg_word:(w <Lit_Chars .xml>)
                                        )
                                        right:<Right_DollarBrace "}">
                                      )
                                    )
                                  )
                                ]
                              )
                            ]
                            right:<Op_DSemi ";;">
                          )
                          (CaseArm
                            left:<Lit_Star "*">
                            pattern:(pat.Words
                              words:[
                                (w <Lit_Star "*"> <Lit_Slash /> <Lit_Star "*">)
                              ]
                            )
                            middle:<Right_CasePat ")">
                            action:[]
                            right:<Op_DSemi ";;">
                          )
                          (CaseArm
                            left:<Lit_Star "*">
                            pattern:(pat.Words words:[(w <Lit_Star "*">)])
                            middle:<Right_CasePat ")">
                            action:[
                              (command.ShAssignment
                                left:<Lit_ArrayLhsOpen "arr[">
                                pairs:[
                                  (AssignPair
                                    left:...0x176e
                                    lhs:(sh_lhs.IndexedName
                                      left:...0x176e
                                      name:arr
                                      index:<Lit_ArithVarLike i>
                                    )
                                    op:assign_op.PlusEqual
                                    rhs:(w <Lit_Slash />)
                                  )
                                ]
                              )
                            ]
                            right:<Op_DSemi ";;">
                          )
                        ]
                        arms_end:<KW_Esac esac>
                      )
                    ]
                    right:<KW_Done done>
                  )
                )
                (command.AndOr
                  children:[
                    (command.DParen
                      left:<Op_DLeftParen "((">
                      child:(w
                        (BracedVarSub
                          left:<Left_DollarBrace "${">
                          name_tok:<VSub_Name arr>
                          var_name:arr
                          prefix_op:<VSub_Pound "#">
                          bracket_op:(bracket_op.WholeArray op_id:Lit_At)
                          right:<Right_DollarBrace "}">
                        )
                      )
                      right:<Op_DRightParen ")">
                    )
                    (command.ShAssignment
                      left:<Lit_VarLike "COMPREPLY+=">
                      pairs:[
                        (AssignPair
                          left:...0x163a
                          lhs:(sh_lhs.Name left:...0x163a name:COMPREPLY)
                          op:assign_op.PlusEqual
                          rhs:(w
                            (word_part.InitializerLiteral
                              left:<Op_LParen "(">
                              pairs:[
                                (InitializerWord.ArrayWord
                                  w:(w
                                    (DQ
                                      (BracedVarSub
                                        left:<Left_DollarBrace "${">
                                        name_tok:<VSub_Name arr>
                                        var_name:arr
                                        bracket_op:(bracket_op.WholeArray
                                          op_id:Lit_At
                                        )
                                        right:<Right_DollarBrace "}">
                                      )
                                    )
                                  )
                                )
                              ]
                              right:<Right_Initializer ")">
                            )
                          )
                        )
                      ]
                    )
                  ]
                  ops:[<Op_DAmp "&&">]
                )
              ]
              right:<KW_Done done>
            )
          )
          (command.AndOr
            children:[
              (command.DBracket
                left:<KW_DLeftBracket "[[">
                expr:(bool_expr.Binary
                  op_id:BoolBinary_GlobNEqual
                  left:(w
                    (BracedVarSub
                      left:<Left_DollarBrace "${">
                      name_tok:<VSub_Name COMPREPLY>
                      var_name:COMPREPLY
                      suffix_op:(suffix_op.Unary
                        op:<VTest_Hyphen ->
                        arg_word:(w)
                      )
                      right:<Right_DollarBrace "}">
                    )
                  )
                  right:(w <Lit_Other "*"> <Lit_Slash />)
                )
                right:<Lit_DRightBracket "]]">
              )
              (C
                (w <Lit_Chars compopt>)
                (w <Lit_Chars -o>)
                (w <Lit_Chars nospace>)
              )
            ]
            ops:[<Op_DPipe "||">]
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_xdg_mime__mimetype()\n{\n    local d i\n    local -a arr\n    for d in /usr/share/mime /usr/local/share/mime; do\n        _comp_compgen -v arr -C \"$d\" -- -f -o plusdirs -X \"!*.xml\" || continue\n        for i in \"${!arr[@]}\"; do\n            case ${arr[i]} in\n                packages*) unset -v \"arr[i]\" ;; # not a MIME type dir\n                *.xml) arr[i]=${arr[i]%.xml} ;;\n                */*) ;;\n                *) arr[i]+=/ ;;\n            esac\n        done\n        ((${#arr[@]})) &&\n            COMPREPLY+=(\"${arr[@]}\")\n    done\n    [[ ${COMPREPLY-} != */ ]] || compopt -o nospace\n}"
    )
    (command.AndOr
      children:[
        (ShFunction
          name_tok:<Lit_Chars _comp_cmd_xdg_mime>
          name:_comp_cmd_xdg_mime
          body:(BraceGroup
            left:<Lit_LBrace "{">
            children:[
              (C
                (w <Lit_Chars local>)
                (w <Lit_Chars cur>)
                (w <Lit_Chars prev>)
                (w <Lit_Chars words>)
                (w <Lit_Chars cword>)
                (w <Lit_Chars comp_args>)
              )
              (command.AndOr
                children:[
                  (C
                    (w <Lit_Chars _comp_initialize>)
                    (w <Lit_Chars -->)
                    (w (DQ ($ VSub_At)))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                ops:[<Op_DPipe "||">]
              )
              (C (w <Lit_Chars local>) (w <Lit_Chars REPLY>))
              (C (w <Lit_Chars _comp_count_args>))
              (C (w <Lit_Chars local>) (w <Lit_VarLike "args="> ($ REPLY)))
              (command.If
                if_kw:<KW_If if>
                arms:[
                  (IfArm
                    keyword:...0x1d4a
                    cond:[
                      (command.Sentence
                        child:(command.DParen
                          left:<Op_DLeftParen "((">
                          child:(arith_expr.Binary
                            op:<Arith_DEqual "==">
                            left:<Lit_ArithVarLike args>
                            right:(w <Lit_Digits 1>)
                          )
                          right:<Op_DRightParen ")">
                        )
                        terminator:<Op_Semi ";">
                      )
                    ]
                    then_kw:<KW_Then then>
                    action:[
                      (command.If
                        if_kw:<KW_If if>
                        arms:[
                          (IfArm
                            keyword:...0x1cde
                            cond:[
                              (command.Sentence
                                child:(command.DBracket
                                  left:<KW_DLeftBracket "[[">
                                  expr:(bool_expr.Binary
                                    op_id:BoolBinary_GlobDEqual
                                    left:(w ($ cur))
                                    right:(w <Lit_Chars -> <Lit_Other "*">)
                                  )
                                  right:<Lit_DRightBracket "]]">
                                )
                                terminator:<Op_Semi ";">
                              )
                            ]
                            then_kw:<KW_Then then>
                            action:[
                              (C
                                (w <Lit_Chars _comp_compgen>)
                                (w <Lit_Chars -->)
                                (w <Lit_Chars -W>)
                                (w (SQ "--help --manual --version"))
                              )
                              (command.ControlFlow
                                keyword:<ControlFlow_Return return>
                              )
                            ]
                            then_tok:...0x1c72
                          )
                        ]
                        else_action:[]
                        fi_kw:<KW_Fi fi>
                      )
                      (C
                        (w <Lit_Chars _comp_compgen>)
                        (w <Lit_Chars -->)
                        (w <Lit_Chars -W>)
                        (w (SQ "query default install uninstall"))
                      )
                      (command.ControlFlow keyword:<ControlFlow_Return return>)
                    ]
                    then_tok:...0x1cfa
                  )
                ]
                else_action:[]
                fi_kw:<KW_Fi fi>
              )
              (command.Case
                case_kw:<KW_Case case>
                to_match:(case_arg.Word
                  w:(w
                    (BracedVarSub
                      left:<Left_DollarBrace "${">
                      name_tok:<VSub_Name words>
                      var_name:words
                      bracket_op:(bracket_op.ArrayIndex expr:(w <Lit_Digits 1>))
                      right:<Right_DollarBrace "}">
                    )
                  )
                )
                arms_start:<KW_In in>
                arms:[
                  (CaseArm
                    left:<Lit_Chars query>
                    pattern:(pat.Words words:[(w <Lit_Chars query>)])
                    middle:<Right_CasePat ")">
                    action:[
                      (command.If
                        if_kw:<KW_If if>
                        arms:[
                          (IfArm
                            keyword:...0x24fe
                            cond:[
                              (command.Sentence
                                child:(command.DParen
                                  left:<Op_DLeftParen "((">
                                  child:(arith_expr.Binary
                                    op:<Arith_DEqual "==">
                                    left:<Lit_ArithVarLike args>
                                    right:(w <Lit_Digits 2>)
                                  )
                                  right:<Op_DRightParen ")">
                                )
                                terminator:<Op_Semi ";">
                              )
                            ]
                            then_kw:<KW_Then then>
                            action:[
                              (C
                                (w <Lit_Chars _comp_compgen>)
                                (w <Lit_Chars -->)
                                (w <Lit_Chars -W>)
                                (w (SQ "filetype default"))
                              )
                              (command.ControlFlow
                                keyword:<ControlFlow_Return return>
                              )
                            ]
                            then_tok:...0x24aa
                          )
                        ]
                        else_action:[]
                        fi_kw:<KW_Fi fi>
                      )
                      (command.AndOr
                        children:[
                          (command.DParen
                            left:<Op_DLeftParen "((">
                            child:(arith_expr.Binary
                              op:<Arith_DEqual "==">
                              left:<Lit_ArithVarLike args>
                              right:(w <Lit_Digits 3>)
                            )
                            right:<Op_DRightParen ")">
                          )
                          (command.ControlFlow
                            keyword:<ControlFlow_Return return>
                          )
                        ]
                        ops:[<Op_DPipe "||">]
                      )
                      (command.Case
                        case_kw:<KW_Case case>
                        to_match:(case_arg.Word
                          w:(w
                            (BracedVarSub
                              left:<Left_DollarBrace "${">
                              name_tok:<VSub_Name words>
                              var_name:words
                              bracket_op:(bracket_op.ArrayIndex
                                expr:(w <Lit_Digits 2>)
                              )
                              right:<Right_DollarBrace "}">
                            )
                          )
                        )
                        arms_start:<KW_In in>
                        arms:[
                          (CaseArm
                            left:<Lit_Chars filetype>
                            pattern:(pat.Words words:[(w <Lit_Chars filetype>)])
                            middle:<Right_CasePat ")">
                            action:[(C (w <Lit_Chars _comp_compgen_filedir>))]
                            right:<Op_DSemi ";;">
                          )
                          (CaseArm
                            left:<Lit_Chars default>
                            pattern:(pat.Words words:[(w <Lit_Chars default>)])
                            middle:<Right_CasePat ")">
                            action:[
                              (C (w <Lit_Chars _comp_cmd_xdg_mime__mimetype>))
                            ]
                            right:<Op_DSemi ";;">
                          )
                        ]
                        arms_end:<KW_Esac esac>
                      )
                    ]
                    right:<Op_DSemi ";;">
                  )
                  (CaseArm
                    left:<Lit_Chars default>
                    pattern:(pat.Words words:[(w <Lit_Chars default>)])
                    middle:<Right_CasePat ")">
                    action:[
                      (command.If
                        if_kw:<KW_If if>
                        arms:[
                          (IfArm
                            keyword:...0x21e6
                            cond:[
                              (command.Sentence
                                child:(command.DParen
                                  left:<Op_DLeftParen "((">
                                  child:(arith_expr.Binary
                                    op:<Arith_DEqual "==">
                                    left:<Lit_ArithVarLike args>
                                    right:(w <Lit_Digits 2>)
                                  )
                                  right:<Op_DRightParen ")">
                                )
                                terminator:<Op_Semi ";">
                              )
                            ]
                            then_kw:<KW_Then then>
                            action:[
                              (C
                                (w <Lit_Chars local>)
                                (w <Lit_Chars -a>)
                                (w <Lit_Chars desktops>)
                              )
                              (command.If
                                if_kw:<KW_If if>
                                arms:[
                                  (IfArm
                                    keyword:...0x212e
                                    cond:[
                                      (command.Sentence
                                        child:(C
                                          (w <Lit_Chars _comp_expand_glob>)
                                          (w <Lit_Chars desktops>)
                                          (w
                                            (SQ
                                              "/usr/share/applications/*.desktop"
                                            )
                                          )
                                        )
                                        terminator:<Op_Semi ";">
                                      )
                                    ]
                                    then_kw:<KW_Then then>
                                    action:[
                                      (command.ShAssignment
                                        left:<Lit_VarLike "desktops=">
                                        pairs:[
                                          (AssignPair
                                            left:...0x2096
                                            lhs:(sh_lhs.Name
                                              left:...0x2096
                                              name:desktops
                                            )
                                            op:assign_op.Equal
                                            rhs:(w
                                              (word_part.InitializerLiteral
                                                left:<Op_LParen "(">
                                                pairs:[
                                                  (InitializerWord.ArrayWord
                                                    w:(w
                                                      (DQ
                                                        (BracedVarSub
                                                          left:<
                                                            Left_DollarBrace
                                                            "${"
                                                          >
                                                          name_tok:<
                                                            VSub_Name
                                                            desktops
                                                          >
                                                          var_name:desktops
                                                          bracket_op:(bracket_op.WholeArray
                                                            op_id:Lit_At
                                                          )
                                                          suffix_op:(suffix_op.Unary
                                                            op:<
                                                              VOp1_DPound
                                                              "##"
                                                            >
                                                            arg_word:(w
                                                              <Lit_Other "*">
                                                              <Lit_Slash />
                                                            )
                                                          )
                                                          right:<
                                                            Right_DollarBrace
                                                            "}"
                                                          >
                                                        )
                                                      )
                                                    )
                                                  )
                                                ]
                                                right:<Right_Initializer ")">
                                              )
                                            )
                                          )
                                        ]
                                      )
                                      (C
                                        (w <Lit_Chars _comp_compgen>)
                                        (w <Lit_Chars -->)
                                        (w <Lit_Chars -W>)
                                        (w (SQ "\"${desktops[@]}\""))
                                      )
                                    ]
                                    then_tok:...0x20b2
                                  )
                                ]
                                else_action:[]
                                fi_kw:<KW_Fi fi>
                              )
                            ]
                            then_tok:...0x2192
                          )
                        ]
                        else_kw:<KW_Else else>
                        else_action:[
                          (C (w <Lit_Chars _comp_cmd_xdg_mime__mimetype>))
                        ]
                        fi_kw:<KW_Fi fi>
                      )
                    ]
                    right:<Op_DSemi ";;">
                  )
                  (CaseArm
                    left:<Lit_Chars install>
                    pattern:(pat.Words words:[(w <Lit_Chars install>)])
                    middle:<Right_CasePat ")">
                    action:[
                      (command.If
                        if_kw:<KW_If if>
                        arms:[
                          (IfArm
                            keyword:...0x294e
                            cond:[
                              (command.Sentence
                                child:(command.DBracket
                                  left:<KW_DLeftBracket "[[">
                                  expr:(bool_expr.Binary
                                    op_id:BoolBinary_GlobDEqual
                                    left:(w ($ cur))
                                    right:(w <Lit_Chars -> <Lit_Other "*">)
                                  )
                                  right:<Lit_DRightBracket "]]">
                                )
                                terminator:<Op_Semi ";">
                              )
                            ]
                            then_kw:<KW_Then then>
                            action:[
                              (C
                                (w <Lit_Chars _comp_compgen>)
                                (w <Lit_Chars -->)
                                (w <Lit_Chars -W>)
                                (w (SQ "--mode --novendor"))
                              )
                            ]
                            then_tok:...0x28de
                          )
                          (IfArm
                            keyword:<KW_Elif elif>
                            cond:[
                              (command.Sentence
                                child:(command.DBracket
                                  left:<KW_DLeftBracket "[[">
                                  expr:(bool_expr.Binary
                                    op_id:BoolBinary_GlobDEqual
                                    left:(w ($ prev))
                                    right:(w <Lit_Chars --mode>)
                                  )
                                  right:<Lit_DRightBracket "]]">
                                )
                                terminator:<Op_Semi ";">
                              )
                            ]
                            then_kw:<KW_Then then>
                            action:[
                              (C
                                (w <Lit_Chars _comp_compgen>)
                                (w <Lit_Chars -->)
                                (w <Lit_Chars -W>)
                                (w (SQ "user system"))
                              )
                            ]
                            then_tok:...0x27da
                          )
                        ]
                        else_kw:<KW_Else else>
                        else_action:[
                          (C
                            (w <Lit_Chars _comp_compgen_filedir>)
                            (w <Lit_Chars xml>)
                          )
                        ]
                        fi_kw:<KW_Fi fi>
                      )
                    ]
                    right:<Op_DSemi ";;">
                  )
                  (CaseArm
                    left:<Lit_Chars uninstall>
                    pattern:(pat.Words words:[(w <Lit_Chars uninstall>)])
                    middle:<Right_CasePat ")">
                    action:[
                      (command.If
                        if_kw:<KW_If if>
                        arms:[
                          (IfArm
                            keyword:...0x267e
                            cond:[
                              (command.Sentence
                                child:(command.DBracket
                                  left:<KW_DLeftBracket "[[">
                                  expr:(bool_expr.Binary
                                    op_id:BoolBinary_GlobDEqual
                                    left:(w ($ cur))
                                    right:(w <Lit_Chars -> <Lit_Other "*">)
                                  )
                                  right:<Lit_DRightBracket "]]">
                                )
                                terminator:<Op_Semi ";">
                              )
                            ]
                            then_kw:<KW_Then then>
                            action:[
                              (C
                                (w <Lit_Chars _comp_compgen>)
                                (w <Lit_Chars -->)
                                (w <Lit_Chars -W>)
                                (w (SQ --mode))
                              )
                            ]
                            then_tok:...0x260e
                          )
                          (IfArm
                            keyword:<KW_Elif elif>
                            cond:[
                              (command.Sentence
                                child:(command.DBracket
                                  left:<KW_DLeftBracket "[[">
                                  expr:(bool_expr.Binary
                                    op_id:BoolBinary_GlobDEqual
                                    left:(w ($ prev))
                                    right:(w <Lit_Chars --mode>)
                                  )
                                  right:<Lit_DRightBracket "]]">
                                )
                                terminator:<Op_Semi ";">
                              )
                            ]
                            then_kw:<KW_Then then>
                            action:[
                              (C
                                (w <Lit_Chars _comp_compgen>)
                                (w <Lit_Chars -->)
                                (w <Lit_Chars -W>)
                                (w (SQ "user system"))
                              )
                            ]
                            then_tok:...0x2fb6
                          )
                        ]
                        else_kw:<KW_Else else>
                        else_action:[
                          (C
                            (w <Lit_Chars _comp_compgen_filedir>)
                            (w <Lit_Chars xml>)
                          )
                        ]
                        fi_kw:<KW_Fi fi>
                      )
                    ]
                    right:<Op_DSemi ";;">
                  )
                ]
                arms_end:<KW_Esac esac>
              )
            ]
            right:<Lit_RBrace "}">
          )
          code_str:"_comp_cmd_xdg_mime()\n{\n    local cur prev words cword comp_args\n    _comp_initialize -- \"$@\" || return\n\n    local REPLY\n    _comp_count_args\n    local args=$REPLY\n    if ((args == 1)); then\n        if [[ $cur == -* ]]; then\n            _comp_compgen -- -W '--help --manual --version'\n            return\n        fi\n        _comp_compgen -- -W 'query default install uninstall'\n        return\n    fi\n\n    case ${words[1]} in\n        query)\n            if ((args == 2)); then\n                _comp_compgen -- -W 'filetype default'\n                return\n            fi\n            ((args == 3)) || return\n            case ${words[2]} in\n                filetype) _comp_compgen_filedir ;;\n                default) _comp_cmd_xdg_mime__mimetype ;;\n            esac\n            ;;\n        default)\n            if ((args == 2)); then\n                local -a desktops\n                if _comp_expand_glob desktops '/usr/share/applications/*.desktop'; then\n                    desktops=(\"${desktops[@]##*/}\")\n                    _comp_compgen -- -W '\"${desktops[@]}\"'\n                fi\n            else\n                _comp_cmd_xdg_mime__mimetype\n            fi\n            ;;\n        install)\n            if [[ $cur == -* ]]; then\n                _comp_compgen -- -W '--mode --novendor'\n            elif [[ $prev == --mode ]]; then\n                _comp_compgen -- -W 'user system'\n            else\n                _comp_compgen_filedir xml\n            fi\n            ;;\n        uninstall)\n            if [[ $cur == -* ]]; then\n                _comp_compgen -- -W '--mode'\n            elif [[ $prev == --mode ]]; then\n                _comp_compgen -- -W 'user system'\n            else\n                _comp_compgen_filedir xml\n            fi\n            ;;\n    esac\n}"
        )
        (C
          (w <Lit_Chars complete>)
          (w <Lit_Chars -F>)
          (w <Lit_Chars _comp_cmd_xdg_mime>)
          (w <Lit_Chars xdg-mime>)
        )
      ]
      ops:[<Op_DAmp "&&">]
    )
  ]
)
(command.AndOr
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_xdg_settings>
      name:_comp_cmd_xdg_settings
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars cur>)
            (w <Lit_Chars prev>)
            (w <Lit_Chars words>)
            (w <Lit_Chars cword>)
            (w <Lit_Chars comp_args>)
          )
          (command.AndOr
            children:[
              (C
                (w <Lit_Chars _comp_initialize>)
                (w <Lit_Chars -->)
                (w (DQ ($ VSub_At)))
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DPipe "||">]
          )
          (command.Case
            case_kw:<KW_Case case>
            to_match:(case_arg.Word w:(w ($ prev)))
            arms_start:<KW_In in>
            arms:[
              (CaseArm
                left:<Lit_Chars --help>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --help>)
                    (w <Lit_Chars --list>)
                    (w <Lit_Chars --manual>)
                    (w <Lit_Chars --version>)
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
            ]
            arms_end:<KW_Esac esac>
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x1a46
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.Binary
                        op_id:BoolBinary_GlobDEqual
                        left:(w ($ cur))
                        right:(w <Lit_Chars -> <Lit_Other "*">)
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (C (w <Lit_Chars _comp_compgen_help>) (w <Lit_Chars ->))
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                then_tok:...0x19da
              )
            ]
            else_action:[]
            fi_kw:<KW_Fi fi>
          )
          (C (w <Lit_Chars local>) (w <Lit_Chars REPLY>))
          (C (w <Lit_Chars _comp_count_args>))
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x17b2
                cond:[
                  (command.Sentence
                    child:(command.DParen
                      left:<Op_DLeftParen "((">
                      child:(arith_expr.Binary
                        op:<Arith_DEqual "==">
                        left:<Lit_ArithVarLike REPLY>
                        right:(w <Lit_Digits 1>)
                      )
                      right:<Op_DRightParen ")">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (DQ <Lit_Chars "get check set">))
                  )
                ]
                then_tok:...0x1762
              )
              (IfArm
                keyword:<KW_Elif elif>
                cond:[
                  (command.Sentence
                    child:(command.DParen
                      left:<Op_DLeftParen "((">
                      child:(arith_expr.Binary
                        op:<Arith_DEqual "==">
                        left:<Lit_ArithVarLike REPLY>
                        right:(w <Lit_Digits 2>)
                      )
                      right:<Op_DRightParen ")">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen_split>)
                    (w <Lit_Chars -->)
                    (w
                      (DQ
                        (CommandSub
                          left_token:<Left_DollarParen "$(">
                          child:(command.Pipeline
                            children:[
                              (C (w (DQ ($ 1))) (w <Lit_Chars --list>))
                              (C
                                (w <Lit_Chars _comp_awk>)
                                (w (SQ "!/^Known/ { print $1 }"))
                              )
                            ]
                            ops:[<Op_Pipe "|">]
                          )
                          right:<Eof_RParen ")">
                        )
                      )
                    )
                  )
                ]
                then_tok:...0x167e
              )
            ]
            else_action:[]
            fi_kw:<KW_Fi fi>
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_xdg_settings()\n{\n    local cur prev words cword comp_args\n    _comp_initialize -- \"$@\" || return\n\n    case $prev in\n        --help | --list | --manual | --version)\n            return\n            ;;\n    esac\n\n    if [[ $cur == -* ]]; then\n        _comp_compgen_help - <<<\"$(\"$1\" --help | tr '{|' '\\n')\"\n        return\n    fi\n\n    local REPLY\n    _comp_count_args\n    if ((REPLY == 1)); then\n        _comp_compgen -- -W \"get check set\"\n    elif ((REPLY == 2)); then\n        _comp_compgen_split -- \"$(\"$1\" --list | _comp_awk '!/^Known/ { print $1 }')\"\n    fi\n}"
    )
    (C
      (w <Lit_Chars complete>)
      (w <Lit_Chars -F>)
      (w <Lit_Chars _comp_cmd_xdg_settings>)
      (w <Lit_Chars xdg-settings>)
    )
  ]
  ops:[<Op_DAmp "&&">]
)
(command.AndOr
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_xev>
      name:_comp_cmd_xev
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars cur>)
            (w <Lit_Chars prev>)
            (w <Lit_Chars words>)
            (w <Lit_Chars cword>)
            (w <Lit_Chars comp_args>)
          )
          (command.AndOr
            children:[
              (C
                (w <Lit_Chars _comp_initialize>)
                (w <Lit_Chars -->)
                (w (DQ ($ VSub_At)))
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DPipe "||">]
          )
          (command.Case
            case_kw:<KW_Case case>
            to_match:(case_arg.Word w:(w ($ prev)))
            arms_start:<KW_In in>
            arms:[
              (CaseArm
                left:<Lit_Chars -display>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars -display>)
                    (w <Lit_Chars -geometry>)
                    (w <Lit_Chars -bw>)
                    (w <Lit_Chars -id>)
                    (w <Lit_Chars -name>)
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars -bs>
                pattern:(pat.Words words:[(w <Lit_Chars -bs>)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ "NotUseful WhenMapped Always"))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars -event>
                pattern:(pat.Words words:[(w <Lit_Chars -event>)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w
                      (SQ
                        "keyboard mouse expose visibility structure\n                substructure focus property colormap owner_grab_button randr\n                button"
                      )
                    )
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
            ]
            arms_end:<KW_Esac esac>
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x185a
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.Binary
                        op_id:BoolBinary_GlobDEqual
                        left:(w ($ cur))
                        right:(w <Lit_Chars -> <Lit_Other "*">)
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (C (w <Lit_Chars _comp_compgen_help>))
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                then_tok:...0x17ee
              )
            ]
            else_action:[]
            fi_kw:<KW_Fi fi>
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_xev()\n{\n    local cur prev words cword comp_args\n    _comp_initialize -- \"$@\" || return\n\n    case $prev in\n        -display | -geometry | -bw | -id | -name)\n            return\n            ;;\n        -bs)\n            _comp_compgen -- -W 'NotUseful WhenMapped Always'\n            return\n            ;;\n        -event)\n            _comp_compgen -- -W 'keyboard mouse expose visibility structure\n                substructure focus property colormap owner_grab_button randr\n                button'\n            return\n            ;;\n    esac\n\n    if [[ $cur == -* ]]; then\n        _comp_compgen_help\n        return\n    fi\n}"
    )
    (C
      (w <Lit_Chars complete>)
      (w <Lit_Chars -F>)
      (w <Lit_Chars _comp_cmd_xev>)
      (w <Lit_Chars xev>)
    )
  ]
  ops:[<Op_DAmp "&&">]
)
(command.AndOr
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_xfreerdp>
      name:_comp_cmd_xfreerdp
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars cur>)
            (w <Lit_Chars prev>)
            (w <Lit_Chars words>)
            (w <Lit_Chars cword>)
            (w <Lit_Chars comp_args>)
          )
          (command.AndOr
            children:[
              (C
                (w <Lit_Chars _comp_initialize>)
                (w <Lit_Chars -n>)
                (w <Lit_Colon ":">)
                (w <Lit_Chars -->)
                (w (DQ ($ VSub_At)))
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DPipe "||">]
          )
          (command.Case
            case_kw:<KW_Case case>
            to_match:(case_arg.Word w:(w ($ prev)))
            arms_start:<KW_In in>
            arms:[
              (CaseArm
                left:<Lit_Chars -k>
                pattern:(pat.Words words:[(w <Lit_Chars -k>)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen_split>)
                    (w <Lit_Chars -->)
                    (w
                      (DQ
                        (CommandSub
                          left_token:<Left_DollarParen "$(">
                          child:(command.Pipeline
                            children:[
                              (C (w (DQ ($ 1))) (w <Lit_Chars --kbd-list>))
                              (C
                                (w <Lit_Chars _comp_awk>)
                                (w (SQ "/^0x/ { print $1 }"))
                              )
                            ]
                            ops:[<Op_Pipe "|">]
                          )
                          right:<Eof_RParen ")">
                        )
                      )
                    )
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars -a>
                pattern:(pat.Words words:[(w <Lit_Chars -a>)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ "8 15 16 24 32"))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars -x>
                pattern:(pat.Words words:[(w <Lit_Chars -x>)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ "broadband modem lan"))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --plugin>
                pattern:(pat.Words words:[(w <Lit_Chars --plugin>)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ "cliprdr rdpsnd rdpdr"))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Slash />
                pattern:(pat.Words
                  words:[
                    (w <Lit_Slash /> <Lit_Chars help>)
                    (w <Lit_Slash /> <Lit_Chars version>)
                    (w <Lit_Chars -h>)
                    (w <Lit_Chars --help>)
                    (w <Lit_Chars --version>)
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
            ]
            arms_end:<KW_Esac esac>
          )
          (command.Case
            case_kw:<KW_Case case>
            to_match:(case_arg.Word w:(w ($ cur)))
            arms_start:<KW_In in>
            arms:[
              (CaseArm
                left:<Lit_Slash />
                pattern:(pat.Words
                  words:[
                    (w
                      <Lit_Slash />
                      <Lit_Chars kbd>
                      <Lit_Colon ":">
                      <Lit_Star "*">
                    )
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (C (w <Lit_Chars local>) (w <Lit_Chars kbd_list>))
                  (command.AndOr
                    children:[
                      (command.ShAssignment
                        left:<Lit_VarLike "kbd_list=">
                        pairs:[
                          (AssignPair
                            left:...0x1fe6
                            lhs:(sh_lhs.Name left:...0x1fe6 name:kbd_list)
                            op:assign_op.Equal
                            rhs:(w
                              (CommandSub
                                left_token:<Left_DollarParen "$(">
                                child:(C
                                  (w (DQ ($ 1)))
                                  (w <Lit_Slash /> <Lit_Chars kbd-list>)
                                )
                                right:<Eof_RParen ")">
                              )
                            )
                          )
                        ]
                      )
                      (command.ShAssignment
                        left:<Lit_VarLike "kbd_list=">
                        pairs:[
                          (AssignPair
                            left:...0x1f12
                            lhs:(sh_lhs.Name left:...0x1f12 name:kbd_list)
                            op:assign_op.Equal
                            rhs:(w
                              (CommandSub
                                left_token:<Left_DollarParen "$(">
                                child:(C
                                  (w (DQ ($ 1)))
                                  (w
                                    <Lit_Slash />
                                    <Lit_Chars list>
                                    <Lit_Colon ":">
                                    <Lit_Chars kbd>
                                  )
                                )
                                right:<Eof_RParen ")">
                              )
                            )
                          )
                        ]
                      )
                    ]
                    ops:[<Op_DPipe "||">]
                  )
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -c>)
                    (w
                      (DQ
                        (BracedVarSub
                          left:<Left_DollarBrace "${">
                          name_tok:<VSub_Name cur>
                          var_name:cur
                          suffix_op:(suffix_op.Unary
                            op:<VOp1_Pound "#">
                            arg_word:(w <Lit_Slash /> <Lit_Chars "kbd:">)
                          )
                          right:<Right_DollarBrace "}">
                        )
                      )
                    )
                    (w <Lit_Chars split>)
                    (w <Lit_Chars -->)
                    (w
                      (DQ
                        (CommandSub
                          left_token:<Left_DollarParen "$(">
                          child:(C
                            (w <Lit_Chars _comp_awk>)
                            (w (SQ "/^0x/ { print $1 }"))
                          )
                          right:<Eof_RParen ")">
                        )
                      )
                    )
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Slash />
                pattern:(pat.Words
                  words:[
                    (w
                      <Lit_Slash />
                      <Lit_Chars bpp>
                      <Lit_Colon ":">
                      <Lit_Star "*">
                    )
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -c>)
                    (w
                      (DQ
                        (BracedVarSub
                          left:<Left_DollarBrace "${">
                          name_tok:<VSub_Name cur>
                          var_name:cur
                          suffix_op:(suffix_op.Unary
                            op:<VOp1_Pound "#">
                            arg_word:(w <Lit_Slash /> <Lit_Chars "bpp:">)
                          )
                          right:<Right_DollarBrace "}">
                        )
                      )
                    )
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ "8 15 16 24 32"))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Slash />
                pattern:(pat.Words
                  words:[
                    (w
                      <Lit_Slash />
                      <Lit_Star "*">
                      <Lit_Colon ":">
                      <Lit_Star "*">
                    )
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
            ]
            arms_end:<KW_Esac esac>
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x1ad6
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.Binary
                        op_id:BoolBinary_GlobDEqual
                        left:(w ($ cur))
                        right:(w <Lit_Slash /> <Lit_Other "*">)
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (C (w <Lit_Chars _comp_compgen_filedir>) (w <Lit_Chars rdp>))
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -a>)
                    (w <Lit_Chars split>)
                    (w <Lit_Chars -->)
                    (w
                      (DQ
                        (CommandSub
                          left_token:<Left_DollarParen "$(">
                          child:(command.Pipeline
                            children:[
                              (C (w (DQ ($ 1))) (w <Lit_Chars --help>))
                              (C
                                (w <Lit_Chars _comp_awk>)
                                (w
                                  (SQ
                                    "$1 ~ /^\\// && $1 !~ /^.(flag$|option:)/ {\n                sub(\":.*\",\":\",$1); print $1 }"
                                  )
                                )
                              )
                            ]
                            ops:[<Op_Pipe "|">]
                          )
                          right:<Eof_RParen ")">
                        )
                      )
                    )
                  )
                  (command.AndOr
                    children:[
                      (command.DBracket
                        left:<KW_DLeftBracket "[[">
                        expr:(bool_expr.Binary
                          op_id:BoolBinary_GlobDEqual
                          left:(w
                            (BracedVarSub
                              left:<Left_DollarBrace "${">
                              name_tok:<VSub_Name COMPREPLY>
                              var_name:COMPREPLY
                              suffix_op:(suffix_op.Unary
                                op:<VTest_Hyphen ->
                                arg_word:(w)
                              )
                              right:<Right_DollarBrace "}">
                            )
                          )
                          right:(w <Lit_Other "*"> <Lit_Colon ":">)
                        )
                        right:<Lit_DRightBracket "]]">
                      )
                      (C
                        (w <Lit_Chars compopt>)
                        (w <Lit_Chars -o>)
                        (w <Lit_Chars nospace>)
                      )
                    ]
                    ops:[<Op_DAmp "&&">]
                  )
                ]
                then_tok:...0x2512
              )
              (IfArm
                keyword:<KW_Elif elif>
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.Binary
                        op_id:BoolBinary_GlobDEqual
                        left:(w ($ cur))
                        right:(w
                          <Lit_Other "[">
                          <Lit_Other "+">
                          <Lit_Chars ->
                          <Lit_Other "]">
                          <Lit_Other "*">
                        )
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (C
                    (w <Lit_Chars local>)
                    (w
                      <Lit_VarLike "char=">
                      (BracedVarSub
                        left:<Left_DollarBrace "${">
                        name_tok:<VSub_Name cur>
                        var_name:cur
                        suffix_op:(suffix_op.Slice
                          begin:(w <Lit_Digits 0>)
                          length:(w <Lit_Digits 1>)
                        )
                        right:<Arith_RBrace "}">
                      )
                    )
                  )
                  (C
                    (w <Lit_Chars local>)
                    (w
                      <Lit_VarLike "help=">
                      (DQ
                        (CommandSub
                          left_token:<Left_DollarParen "$(">
                          child:(C (w (DQ ($ 1))) (w <Lit_Chars --help>))
                          right:<Eof_RParen ")">
                        )
                      )
                    )
                  )
                  (command.If
                    if_kw:<KW_If if>
                    arms:[
                      (IfArm
                        keyword:...0x210a
                        cond:[
                          (command.Sentence
                            child:(command.DBracket
                              left:<KW_DLeftBracket "[[">
                              expr:(bool_expr.Binary
                                op_id:BoolBinary_GlobDEqual
                                left:(w ($ help))
                                right:(w
                                  <Lit_Other "*">
                                  <Lit_Slash />
                                  <Lit_Chars help>
                                  <Lit_Other "*">
                                )
                              )
                              right:<Lit_DRightBracket "]]">
                            )
                            terminator:<Op_Semi ";">
                          )
                        ]
                        then_kw:<KW_Then then>
                        action:[
                          (C
                            (w <Lit_Chars _comp_compgen_split>)
                            (w <Lit_Chars -->)
                            (w
                              (DQ
                                (CommandSub
                                  left_token:<Left_DollarParen "$(">
                                  child:(C
                                    (w <Lit_Chars _comp_awk>)
                                    (w
                                      (SQ
                                        "$1 ~ /^[+-]/ && $1 !~ /^.toggle$/ {\n                    sub(\"^.\",\""
                                      )
                                      (DQ ($ char))
                                      (SQ "\",$1); print $1 }")
                                    )
                                  )
                                  right:<Eof_RParen ")">
                                )
                              )
                            )
                          )
                        ]
                        then_tok:...0x2096
                      )
                    ]
                    else_kw:<KW_Else else>
                    else_action:[
                      (C
                        (w <Lit_Chars _comp_compgen>)
                        (w <Lit_Chars -R>)
                        (w <Lit_Chars help>)
                        (w <Lit_Chars ->)
                      )
                      (command.AndOr
                        children:[
                          (command.DParen
                            left:<Op_DLeftParen "((">
                            child:(w
                              (BracedVarSub
                                left:<Left_DollarBrace "${">
                                name_tok:<VSub_Name COMPREPLY>
                                var_name:COMPREPLY
                                prefix_op:<VSub_Pound "#">
                                bracket_op:(bracket_op.WholeArray op_id:Lit_At)
                                right:<Right_DollarBrace "}">
                              )
                            )
                            right:<Op_DRightParen ")">
                          )
                          (C
                            (w <Lit_Chars _comp_compgen>)
                            (w <Lit_Chars -->)
                            (w <Lit_Chars -W>)
                            (w (SQ "\"${COMPREPLY[@]%:}\""))
                          )
                        ]
                        ops:[<Op_DAmp "&&">]
                      )
                    ]
                    fi_kw:<KW_Fi fi>
                  )
                ]
                then_tok:...0x222e
              )
            ]
            else_kw:<KW_Else else>
            else_action:[
              (C (w <Lit_Chars _comp_compgen_filedir>) (w <Lit_Chars rdp>))
              (C
                (w <Lit_Chars _comp_compgen>)
                (w <Lit_Chars -a>)
                (w <Lit_Chars split>)
                (w <Lit_Chars -->)
                (w
                  (DQ
                    (CommandSub
                      left_token:<Left_DollarParen "$(">
                      child:(C
                        (w <Lit_Chars _comp_awk>)
                        (w (SQ "{print $1}"))
                        (w
                          (word_part.TildeSub left:<Lit_Tilde "~">)
                          <Lit_Slash />
                          <Lit_Chars .freerdp>
                          <Lit_Slash />
                          <Lit_Chars known_hosts>
                        )
                      )
                      right:<Eof_RParen ")">
                    )
                  )
                )
              )
            ]
            fi_kw:<KW_Fi fi>
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_xfreerdp()\n{\n    local cur prev words cword comp_args\n    _comp_initialize -n : -- \"$@\" || return\n\n    case $prev in\n        -k)\n            _comp_compgen_split -- \"$(\"$1\" --kbd-list |\n                _comp_awk '/^0x/ { print $1 }')\"\n            return\n            ;;\n        -a)\n            _comp_compgen -- -W '8 15 16 24 32'\n            return\n            ;;\n        -x)\n            _comp_compgen -- -W 'broadband modem lan'\n            return\n            ;;\n        --plugin)\n            _comp_compgen -- -W 'cliprdr rdpsnd rdpdr'\n            return\n            ;;\n        /help | /version | -h | --help | --version)\n            return\n            ;;\n    esac\n\n    case $cur in\n        /kbd:*)\n            local kbd_list\n            kbd_list=$(\"$1\" /kbd-list 2>/dev/null) ||\n                kbd_list=$(\"$1\" /list:kbd 2>/dev/null)\n            _comp_compgen -c \"${cur#/kbd:}\" split -- \"$(\n                _comp_awk '/^0x/ { print $1 }' <<<\"$kbd_list\"\n            )\"\n            return\n            ;;\n        /bpp:*)\n            _comp_compgen -c \"${cur#/bpp:}\" -- -W '8 15 16 24 32'\n            return\n            ;;\n        /*:*)\n            return\n            ;;\n    esac\n\n    if [[ $cur == /* ]]; then\n        _comp_compgen_filedir rdp\n        _comp_compgen -a split -- \"$(\n            \"$1\" --help | _comp_awk '$1 ~ /^\\// && $1 !~ /^.(flag$|option:)/ {\n                sub(\":.*\",\":\",$1); print $1 }'\n        )\"\n        [[ ${COMPREPLY-} == *: ]] && compopt -o nospace\n    elif [[ $cur == [+-]* ]]; then\n        local char=${cur:0:1}\n        local help=\"$(\"$1\" --help)\"\n        if [[ $help == */help* ]]; then # new/slash syntax\n            _comp_compgen_split -- \"$(_comp_awk '$1 ~ /^[+-]/ && $1 !~ /^.toggle$/ {\n                    sub(\"^.\",\"'\"$char\"'\",$1); print $1 }' <<<\"$help\")\"\n        else # old/dash syntax\n            _comp_compgen -R help - <<<\"$help\"\n            ((${#COMPREPLY[@]})) &&\n                _comp_compgen -- -W '\"${COMPREPLY[@]%:}\"'\n        fi\n    else\n        _comp_compgen_filedir rdp\n        _comp_compgen -a split -- \"$(\n            _comp_awk '{print $1}' ~/.freerdp/known_hosts 2>/dev/null\n        )\"\n    fi\n\n}"
    )
    (C
      (w <Lit_Chars complete>)
      (w <Lit_Chars -F>)
      (w <Lit_Chars _comp_cmd_xfreerdp>)
      (w <Lit_Chars xfreerdp>)
    )
  ]
  ops:[<Op_DAmp "&&">]
)
(command.AndOr
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_xgamma>
      name:_comp_cmd_xgamma
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars cur>)
            (w <Lit_Chars prev>)
            (w <Lit_Chars words>)
            (w <Lit_Chars cword>)
            (w <Lit_Chars comp_args>)
          )
          (command.AndOr
            children:[
              (C
                (w <Lit_Chars _comp_initialize>)
                (w <Lit_Chars -n>)
                (w <Lit_Colon ":">)
                (w <Lit_Chars -->)
                (w (DQ ($ VSub_At)))
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DPipe "||">]
          )
          (command.Case
            case_kw:<KW_Case case>
            to_match:(case_arg.Word w:(w (DQ ($ prev))))
            arms_start:<KW_In in>
            arms:[
              (CaseArm
                left:<Lit_Chars -screen>
                pattern:(pat.Words words:[(w <Lit_Chars -screen>)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars local>)
                    (w
                      <Lit_VarLike "screens=">
                      (CommandSub
                        left_token:<Left_DollarParen "$(">
                        child:(command.Pipeline
                          children:[
                            (C (w <Lit_Chars xrandr>) (w <Lit_Chars --query>))
                            (C
                              (w <Lit_Chars command>)
                              (w <Lit_Chars sed>)
                              (w <Lit_Chars -n>)
                              (w
                                (SQ
                                  "/^Screen /s|^Screen \\{1,\\}\\(.*\\):.*$|\\1|p"
                                )
                              )
                            )
                          ]
                          ops:[<Op_Pipe "|">]
                        )
                        right:<Eof_RParen ")">
                      )
                    )
                  )
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (DQ ($ screens)))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars -gamma>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars -gamma>)
                    (w <Lit_Chars -rgamma>)
                    (w <Lit_Chars -ggamma>)
                    (w <Lit_Chars -bgamma>)
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (command.If
                    if_kw:<KW_If if>
                    arms:[
                      (IfArm
                        keyword:...0x1846
                        cond:[
                          (command.Sentence
                            child:(command.DBracket
                              left:<KW_DLeftBracket "[[">
                              expr:(bool_expr.LogicalAnd
                                left:(bool_expr.WordTest w:(w ($ cur)))
                                right:(bool_expr.Binary
                                  op_id:BoolBinary_GlobNEqual
                                  left:(w ($ cur))
                                  right:(w
                                    <Lit_Other "*">
                                    <Lit_Chars .>
                                    <Lit_Other "*">
                                  )
                                )
                              )
                              right:<Lit_DRightBracket "]]">
                            )
                            terminator:<Op_Semi ";">
                          )
                        ]
                        then_kw:<KW_Then then>
                        action:[
                          (command.ShAssignment
                            left:<Lit_VarLike "COMPREPLY=">
                            pairs:[
                              (AssignPair
                                left:...0x179e
                                lhs:(sh_lhs.Name left:...0x179e name:COMPREPLY)
                                op:assign_op.Equal
                                rhs:(w
                                  (word_part.InitializerLiteral
                                    left:<Op_LParen "(">
                                    pairs:[
                                      (InitializerWord.ArrayWord
                                        w:(w <Lit_Chars .>)
                                      )
                                    ]
                                    right:<Right_Initializer ")">
                                  )
                                )
                              )
                            ]
                          )
                        ]
                        then_tok:...0x17be
                      )
                    ]
                    else_action:[]
                    fi_kw:<KW_Fi fi>
                  )
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -aR>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (DQ <Lit_Chars "{0..9}">))
                  )
                  (C
                    (w <Lit_Chars compopt>)
                    (w <Lit_Chars -o>)
                    (w <Lit_Chars nospace>)
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars -display>
                pattern:(pat.Words words:[(w <Lit_Chars -display>)])
                middle:<Right_CasePat ")">
                action:[
                  (command.If
                    if_kw:<KW_If if>
                    arms:[
                      (IfArm
                        keyword:...0x15da
                        cond:[
                          (command.Sentence
                            child:(command.DBracket
                              left:<KW_DLeftBracket "[[">
                              expr:(bool_expr.LogicalAnd
                                left:(bool_expr.Binary
                                  op_id:BoolBinary_GlobDEqual
                                  left:(w ($ cur))
                                  right:(w <Lit_Colon ":"> <Lit_Other "*">)
                                )
                                right:(bool_expr.Binary
                                  op_id:BoolBinary_GlobNEqual
                                  left:(w ($ cur))
                                  right:(w
                                    <Lit_Colon ":">
                                    <Lit_Other "*">
                                    <Lit_Chars .>
                                    <Lit_Other "*">
                                  )
                                )
                              )
                              right:<Lit_DRightBracket "]]">
                            )
                            terminator:<Op_Semi ";">
                          )
                        ]
                        then_kw:<KW_Then then>
                        action:[
                          (C
                            (w <Lit_Chars local>)
                            (w
                              <Lit_VarLike "display=">
                              (BracedVarSub
                                left:<Left_DollarBrace "${">
                                name_tok:<VSub_Name cur>
                                var_name:cur
                                suffix_op:(suffix_op.Unary
                                  op:<VOp1_Pound "#">
                                  arg_word:(w <Lit_Chars ":">)
                                )
                                right:<Right_DollarBrace "}">
                              )
                            )
                          )
                          (C
                            (w <Lit_Chars _comp_compgen>)
                            (w <Lit_Chars -R>)
                            (w <Lit_Chars -->)
                            (w <Lit_Chars -W>)
                            (w
                              (DQ
                                (BracedVarSub
                                  left:<Left_DollarBrace "${">
                                  name_tok:<VSub_Name display>
                                  var_name:display
                                  suffix_op:(suffix_op.Unary
                                    op:<VTest_ColonHyphen ":-">
                                    arg_word:(w <Lit_Chars 0>)
                                  )
                                  right:<Right_DollarBrace "}">
                                )
                                <Lit_Chars .>
                              )
                            )
                          )
                          (C
                            (w <Lit_Chars compopt>)
                            (w <Lit_Chars -o>)
                            (w <Lit_Chars nospace>)
                          )
                        ]
                        then_tok:...0x1fd6
                      )
                      (IfArm
                        keyword:<KW_Elif elif>
                        cond:[
                          (command.Sentence
                            child:(command.DBracket
                              left:<KW_DLeftBracket "[[">
                              expr:(bool_expr.Binary
                                op_id:BoolBinary_GlobDEqual
                                left:(w ($ cur))
                                right:(w
                                  <Lit_Colon ":">
                                  <Lit_Other "*">
                                  <Lit_Chars .>
                                  <Lit_Other "*">
                                )
                              )
                              right:<Lit_DRightBracket "]]">
                            )
                            terminator:<Op_Semi ";">
                          )
                        ]
                        then_kw:<KW_Then then>
                        action:[
                          (C
                            (w <Lit_Chars local>)
                            (w <Lit_Chars t>)
                            (w
                              <Lit_VarLike "screens=">
                              (CommandSub
                                left_token:<Left_DollarParen "$(">
                                child:(command.Pipeline
                                  children:[
                                    (C
                                      (w <Lit_Chars xrandr>)
                                      (w <Lit_Chars --query>)
                                    )
                                    (C
                                      (w <Lit_Chars command>)
                                      (w <Lit_Chars sed>)
                                      (w <Lit_Chars -ne>)
                                      (w
                                        (SQ
                                          "/^Screen /s|^Screen \\{1,\\}\\(.*\\):.*$|\\1|p"
                                        )
                                      )
                                    )
                                  ]
                                  ops:[<Op_Pipe "|">]
                                )
                                right:<Eof_RParen ")">
                              )
                            )
                          )
                          (command.ShAssignment
                            left:<Lit_VarLike "t=">
                            pairs:[
                              (AssignPair
                                left:...0x1c62
                                lhs:(sh_lhs.Name left:...0x1c62 name:t)
                                op:assign_op.Equal
                                rhs:(w
                                  (DQ
                                    (BracedVarSub
                                      left:<Left_DollarBrace "${">
                                      name_tok:<VSub_Name cur>
                                      var_name:cur
                                      suffix_op:(suffix_op.Unary
                                        op:<VOp1_Pound "#">
                                        arg_word:(w <Lit_Chars ":">)
                                      )
                                      right:<Right_DollarBrace "}">
                                    )
                                  )
                                )
                              )
                            ]
                          )
                          (C
                            (w <Lit_Chars _comp_compgen>)
                            (w <Lit_Chars -c>)
                            (w
                              (DQ
                                (BracedVarSub
                                  left:<Left_DollarBrace "${">
                                  name_tok:<VSub_Name cur>
                                  var_name:cur
                                  suffix_op:(suffix_op.Unary
                                    op:<VOp1_DPound "##">
                                    arg_word:(w <Lit_Other "*"> <Lit_Chars .>)
                                  )
                                  right:<Right_DollarBrace "}">
                                )
                              )
                            )
                            (w <Lit_Chars -->)
                            (w <Lit_Chars -P>)
                            (w
                              (DQ
                                (BracedVarSub
                                  left:<Left_DollarBrace "${">
                                  name_tok:<VSub_Name t>
                                  var_name:t
                                  suffix_op:(suffix_op.Unary
                                    op:<VOp1_Percent "%">
                                    arg_word:(w <Lit_Chars .> <Lit_Other "*">)
                                  )
                                  right:<Right_DollarBrace "}">
                                )
                                <Lit_Chars .>
                              )
                            )
                            (w <Lit_Chars -W>)
                            (w (SQ "$screens"))
                          )
                        ]
                        then_tok:...0x1dfe
                      )
                      (IfArm
                        keyword:<KW_Elif elif>
                        cond:[
                          (command.Sentence
                            child:(command.DBracket
                              left:<KW_DLeftBracket "[[">
                              expr:(bool_expr.Binary
                                op_id:BoolBinary_GlobNEqual
                                left:(w ($ cur))
                                right:(w
                                  <Lit_Other "*">
                                  <Lit_Colon ":">
                                  <Lit_Other "*">
                                )
                              )
                              right:<Lit_DRightBracket "]]">
                            )
                            terminator:<Op_Semi ";">
                          )
                        ]
                        then_kw:<KW_Then then>
                        action:[
                          (C
                            (w <Lit_Chars _comp_compgen_known_hosts>)
                            (w <Lit_Chars -c>)
                            (w <Lit_Chars -->)
                            (w (DQ ($ cur)))
                          )
                          (command.If
                            if_kw:<KW_If if>
                            arms:[
                              (IfArm
                                keyword:...0x24a2
                                cond:[
                                  (command.Sentence
                                    child:(command.DBracket
                                      left:<KW_DLeftBracket "[[">
                                      expr:(bool_expr.LogicalNot
                                        child:(bool_expr.WordTest w:(w ($ cur)))
                                      )
                                      right:<Lit_DRightBracket "]]">
                                    )
                                    terminator:<Op_Semi ";">
                                  )
                                ]
                                then_kw:<KW_Then then>
                                action:[
                                  (command.ShAssignment
                                    left:<Lit_VarLike "COMPREPLY+=">
                                    pairs:[
                                      (AssignPair
                                        left:...0x242a
                                        lhs:(sh_lhs.Name
                                          left:...0x242a
                                          name:COMPREPLY
                                        )
                                        op:assign_op.PlusEqual
                                        rhs:(w
                                          (word_part.InitializerLiteral
                                            left:<Op_LParen "(">
                                            pairs:[
                                              (InitializerWord.ArrayWord
                                                w:(w <Lit_Colon ":">)
                                              )
                                            ]
                                            right:<Right_Initializer ")">
                                          )
                                        )
                                      )
                                    ]
                                  )
                                ]
                                then_tok:...0x2446
                              )
                            ]
                            else_action:[]
                            fi_kw:<KW_Fi fi>
                          )
                          (C
                            (w <Lit_Chars compopt>)
                            (w <Lit_Chars -o>)
                            (w <Lit_Chars nospace>)
                          )
                        ]
                        then_tok:...0x253e
                      )
                    ]
                    else_action:[]
                    fi_kw:<KW_Fi fi>
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
            ]
            arms_end:<KW_Esac esac>
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x22ba
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.Binary
                        op_id:BoolBinary_GlobDEqual
                        left:(w ($ cur))
                        right:(w <Lit_Chars -> <Lit_Other "*">)
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen_help>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -help>)
                  )
                  (command.If
                    if_kw:<KW_If if>
                    arms:[
                      (IfArm
                        keyword:...0x21e2
                        cond:[
                          (command.Sentence
                            child:(command.DBracket
                              left:<KW_DLeftBracket "[[">
                              expr:(bool_expr.WordTest
                                w:(w
                                  (BracedVarSub
                                    left:<Left_DollarBrace "${">
                                    name_tok:<VSub_Name COMPREPLY>
                                    var_name:COMPREPLY
                                    suffix_op:(suffix_op.Unary
                                      op:<VTest_Hyphen ->
                                      arg_word:(w)
                                    )
                                    right:<Right_DollarBrace "}">
                                  )
                                )
                              )
                              right:<Lit_DRightBracket "]]">
                            )
                            terminator:<Op_Semi ";">
                          )
                        ]
                        then_kw:<KW_Then then>
                        action:[
                          (command.AndOr
                            children:[
                              (command.DBracket
                                left:<KW_DLeftBracket "[[">
                                expr:(bool_expr.Binary
                                  op_id:BoolBinary_GlobDEqual
                                  left:(w ($ COMPREPLY))
                                  right:(w
                                    <Lit_Other "*">
                                    <BoolBinary_GlobEqual "=">
                                  )
                                )
                                right:<Lit_DRightBracket "]]">
                              )
                              (C
                                (w <Lit_Chars compopt>)
                                (w <Lit_Chars -o>)
                                (w <Lit_Chars nospace>)
                              )
                            ]
                            ops:[<Op_DAmp "&&">]
                          )
                          (command.ControlFlow
                            keyword:<ControlFlow_Return return>
                          )
                        ]
                        then_tok:...0x2182
                      )
                    ]
                    else_action:[]
                    fi_kw:<KW_Fi fi>
                  )
                ]
                then_tok:...0x224e
              )
            ]
            else_action:[]
            fi_kw:<KW_Fi fi>
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_xgamma()\n{\n    local cur prev words cword comp_args\n    _comp_initialize -n : -- \"$@\" || return\n\n    case \"$prev\" in\n        -screen)\n            local screens=$(xrandr --query 2>/dev/null | command sed -n \\\n                '/^Screen /s|^Screen \\{1,\\}\\(.*\\):.*$|\\1|p' 2>/dev/null)\n            _comp_compgen -- -W \"$screens\"\n            return\n            ;;\n        -gamma | -rgamma | -ggamma | -bgamma)\n            # expect f.f\n            if [[ $cur && $cur != *.* ]]; then\n                COMPREPLY=(.)\n            fi\n            _comp_compgen -aR -- -W \"{0..9}\"\n            compopt -o nospace\n            return\n            ;;\n        -display)\n            # expect hostname:displaynumber.screennumber\n            if [[ $cur == :* && $cur != :*.* ]]; then\n                # FIXME: where to get local display numbers?\n                local display=${cur#:}\n                _comp_compgen -R -- -W \"${display:-0}.\"\n                compopt -o nospace\n            elif [[ $cur == :*.* ]]; then\n                # local screen numbers\n                local t screens=$(xrandr --query 2>/dev/null | command sed -ne \\\n                    '/^Screen /s|^Screen \\{1,\\}\\(.*\\):.*$|\\1|p' 2>/dev/null)\n                t=\"${cur#:}\"\n                _comp_compgen -c \"${cur##*.}\" -- -P \"${t%.*}.\" -W '$screens'\n            elif [[ $cur != *:* ]]; then\n                # complete hostnames\n                _comp_compgen_known_hosts -c -- \"$cur\"\n                if [[ ! $cur ]]; then\n                    COMPREPLY+=(:)\n                fi\n                compopt -o nospace\n            fi\n            # no display completion for remote hosts\n            return\n            ;;\n    esac\n\n    if [[ $cur == -* ]]; then\n        _comp_compgen_help -- -help\n        if [[ ${COMPREPLY-} ]]; then\n            [[ $COMPREPLY == *= ]] && compopt -o nospace\n            return\n        fi\n    fi\n}"
    )
    (C
      (w <Lit_Chars complete>)
      (w <Lit_Chars -F>)
      (w <Lit_Chars _comp_cmd_xgamma>)
      (w <Lit_Chars xgamma>)
    )
  ]
  ops:[<Op_DAmp "&&">]
)
(command.AndOr
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_xhost>
      name:_comp_cmd_xhost
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars cur>)
            (w <Lit_Chars prev>)
            (w <Lit_Chars words>)
            (w <Lit_Chars cword>)
            (w <Lit_Chars comp_args>)
          )
          (command.AndOr
            children:[
              (C
                (w <Lit_Chars _comp_initialize>)
                (w <Lit_Chars -->)
                (w (DQ ($ VSub_At)))
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DPipe "||">]
          )
          (command.Case
            case_kw:<KW_Case case>
            to_match:(case_arg.Word w:(w ($ cur)))
            arms_start:<KW_In in>
            arms:[
              (CaseArm
                left:<Lit_Other "+">
                pattern:(pat.Words words:[(w <Lit_Other "+"> <Lit_Star "*">)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen_known_hosts>)
                    (w <Lit_Chars -p> <Lit_Other "+">)
                    (w <Lit_Chars -->)
                    (w
                      (DQ
                        (BracedVarSub
                          left:<Left_DollarBrace "${">
                          name_tok:<VSub_Name cur>
                          var_name:cur
                          suffix_op:(suffix_op.Slice begin:(w <Lit_Digits 1>))
                          right:<Arith_RBrace "}">
                        )
                      )
                    )
                  )
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars ->
                pattern:(pat.Words words:[(w <Lit_Chars -> <Lit_Star "*">)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen_known_hosts>)
                    (w <Lit_Chars -p->)
                    (w <Lit_Chars -->)
                    (w
                      (DQ
                        (BracedVarSub
                          left:<Left_DollarBrace "${">
                          name_tok:<VSub_Name cur>
                          var_name:cur
                          suffix_op:(suffix_op.Slice begin:(w <Lit_Digits 1>))
                          right:<Arith_RBrace "}">
                        )
                      )
                    )
                  )
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Star "*">
                pattern:(pat.Words words:[(w <Lit_Star "*">)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen_known_hosts>)
                    (w <Lit_Chars -->)
                    (w (DQ ($ cur)))
                  )
                ]
                right:<Op_DSemi ";;">
              )
            ]
            arms_end:<KW_Esac esac>
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_xhost()\n{\n    local cur prev words cword comp_args\n    _comp_initialize -- \"$@\" || return\n\n    case $cur in\n        +*) _comp_compgen_known_hosts -p+ -- \"${cur:1}\" ;;\n        -*) _comp_compgen_known_hosts -p- -- \"${cur:1}\" ;;\n        *) _comp_compgen_known_hosts -- \"$cur\" ;;\n    esac\n}"
    )
    (C
      (w <Lit_Chars complete>)
      (w <Lit_Chars -F>)
      (w <Lit_Chars _comp_cmd_xhost>)
      (w <Lit_Chars xhost>)
    )
  ]
  ops:[<Op_DAmp "&&">]
)
(command.CommandList
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_xm__domain_names>
      name:_comp_cmd_xm__domain_names
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars _comp_compgen_split>)
            (w <Lit_Chars -->)
            (w
              (DQ
                (CommandSub
                  left_token:<Left_DollarParen "$(">
                  child:(command.Pipeline
                    children:[
                      (C (w <Lit_Chars xm>) (w <Lit_Chars list>))
                      (C
                        (w <Lit_Chars _comp_awk>)
                        (w (SQ "!/Name|Domain-0/ { print $1 }"))
                      )
                    ]
                    ops:[<Op_Pipe "|">]
                  )
                  right:<Eof_RParen ")">
                )
              )
            )
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_xm__domain_names()\n{\n    _comp_compgen_split -- \"$(xm list 2>/dev/null |\n        _comp_awk '!/Name|Domain-0/ { print $1 }')\"\n}"
    )
    (command.AndOr
      children:[
        (ShFunction
          name_tok:<Lit_Chars _comp_cmd_xm>
          name:_comp_cmd_xm
          body:(BraceGroup
            left:<Lit_LBrace "{">
            children:[
              (C
                (w <Lit_Chars local>)
                (w <Lit_Chars cur>)
                (w <Lit_Chars prev>)
                (w <Lit_Chars words>)
                (w <Lit_Chars cword>)
                (w <Lit_Chars comp_args>)
              )
              (command.AndOr
                children:[
                  (C
                    (w <Lit_Chars _comp_initialize>)
                    (w <Lit_Chars -->)
                    (w (DQ ($ VSub_At)))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                ops:[<Op_DPipe "||">]
              )
              (C
                (w <Lit_Chars local>)
                (w <Lit_Chars REPLY>)
                (w <Lit_Chars command>)
                (w <Lit_Chars commands>)
                (w <Lit_Chars options>)
              )
              (command.ShAssignment
                left:<Lit_VarLike "commands=">
                pairs:[
                  (AssignPair
                    left:...0x18d2
                    lhs:(sh_lhs.Name left:...0x18d2 name:commands)
                    op:assign_op.Equal
                    rhs:(w
                      (SQ
                        "console vncviewer create new delete destroy domid domname\n        dump-core list mem-max mem-set migrate pause reboot rename reset\n        restore resume save shutdown start suspend sysrq trigger top unpause\n        uptime usb-add usb-del vcpu-list vcpu-pin vcpu-set debug-keys dmesg\n        info log serve sched-credit sched-sedf block-attach block-detach\n        block-list block-configure network-attach network-detach network-list\n        vtpm-list pci-attach pci-detach pci-list pci-list-assignable-devices\n        scsi-attach scsi-detach scsi-list vnet-list vnet-create vnet-delete\n        labels addlabel rmlabel getlabel dry-run resources dumppolicy setpolicy\n        resetpolicy getpolicy shell help"
                      )
                    )
                  )
                ]
              )
              (command.If
                if_kw:<KW_If if>
                arms:[
                  (IfArm
                    keyword:...0x182a
                    cond:[
                      (command.Sentence
                        child:(command.DParen
                          left:<Op_DLeftParen "((">
                          child:(arith_expr.Binary
                            op:<Arith_DEqual "==">
                            left:<Lit_ArithVarLike cword>
                            right:(w <Lit_Digits 1>)
                          )
                          right:<Op_DRightParen ")">
                        )
                        terminator:<Op_Semi ";">
                      )
                    ]
                    then_kw:<KW_Then then>
                    action:[
                      (C
                        (w <Lit_Chars _comp_compgen>)
                        (w <Lit_Chars -->)
                        (w <Lit_Chars -W>)
                        (w (DQ ($ commands)))
                      )
                    ]
                    then_tok:...0x17da
                  )
                ]
                else_kw:<KW_Else else>
                else_action:[
                  (command.If
                    if_kw:<KW_If if>
                    arms:[
                      (IfArm
                        keyword:...0x172a
                        cond:[
                          (command.Sentence
                            child:(command.DBracket
                              left:<KW_DLeftBracket "[[">
                              expr:(bool_expr.Binary
                                op_id:BoolBinary_GlobDEqual
                                left:(w ($ cur))
                                right:(w
                                  <Lit_Other "*">
                                  <BoolBinary_GlobEqual "=">
                                  <Lit_Other "*">
                                )
                              )
                              right:<Lit_DRightBracket "]]">
                            )
                            terminator:<Op_Semi ";">
                          )
                        ]
                        then_kw:<KW_Then then>
                        action:[
                          (command.ShAssignment
                            left:<Lit_VarLike "prev=">
                            pairs:[
                              (AssignPair
                                left:...0x169a
                                lhs:(sh_lhs.Name left:...0x169a name:prev)
                                op:assign_op.Equal
                                rhs:(w
                                  (BracedVarSub
                                    left:<Left_DollarBrace "${">
                                    name_tok:<VSub_Name cur>
                                    var_name:cur
                                    suffix_op:(suffix_op.PatSub
                                      pat:(w <Lit_Chars "="> <Lit_Other "*">)
                                      replace:(w)
                                      replace_mode:Undefined_Tok
                                      slash_tok:<VOp2_Slash />
                                    )
                                    right:<Right_DollarBrace "}">
                                  )
                                )
                              )
                            ]
                          )
                          (command.ShAssignment
                            left:<Lit_VarLike "cur=">
                            pairs:[
                              (AssignPair
                                left:...0x163e
                                lhs:(sh_lhs.Name left:...0x163e name:cur)
                                op:assign_op.Equal
                                rhs:(w
                                  (BracedVarSub
                                    left:<Left_DollarBrace "${">
                                    name_tok:<VSub_Name cur>
                                    var_name:cur
                                    suffix_op:(suffix_op.PatSub
                                      pat:(w <Lit_Other "*"> <Lit_Chars "=">)
                                      replace:(w)
                                      replace_mode:Undefined_Tok
                                      slash_tok:<VOp2_Slash />
                                    )
                                    right:<Right_DollarBrace "}">
                                  )
                                )
                              )
                            ]
                          )
                        ]
                        then_tok:...0x16ba
                      )
                    ]
                    else_action:[]
                    fi_kw:<KW_Fi fi>
                  )
                  (command.ShAssignment
                    left:<Lit_VarLike "command=">
                    pairs:[
                      (AssignPair
                        left:...0x15b2
                        lhs:(sh_lhs.Name left:...0x15b2 name:command)
                        op:assign_op.Equal
                        rhs:(w
                          (BracedVarSub
                            left:<Left_DollarBrace "${">
                            name_tok:<VSub_Name words>
                            var_name:words
                            bracket_op:(bracket_op.ArrayIndex
                              expr:(w <Lit_Digits 1>)
                            )
                            right:<Right_DollarBrace "}">
                          )
                        )
                      )
                    ]
                  )
                  (command.If
                    if_kw:<KW_If if>
                    arms:[
                      (IfArm
                        keyword:...0x155a
                        cond:[
                          (command.Sentence
                            child:(command.DBracket
                              left:<KW_DLeftBracket "[[">
                              expr:(bool_expr.Binary
                                op_id:BoolBinary_GlobDEqual
                                left:(w ($ cur))
                                right:(w <Lit_Chars -> <Lit_Other "*">)
                              )
                              right:<Lit_DRightBracket "]]">
                            )
                            terminator:<Op_Semi ";">
                          )
                        ]
                        then_kw:<KW_Then then>
                        action:[
                          (command.Case
                            case_kw:<KW_Case case>
                            to_match:(case_arg.Word w:(w ($ command)))
                            arms_start:<KW_In in>
                            arms:[
                              (CaseArm
                                left:<Lit_Chars create>
                                pattern:(pat.Words
                                  words:[(w <Lit_Chars create>)]
                                )
                                middle:<Right_CasePat ")">
                                action:[
                                  (command.ShAssignment
                                    left:<Lit_VarLike "options=">
                                    pairs:[
                                      (AssignPair
                                        left:...0x1f12
                                        lhs:(sh_lhs.Name
                                          left:...0x1f12
                                          name:options
                                        )
                                        op:assign_op.Equal
                                        rhs:(w (SQ -c))
                                      )
                                    ]
                                  )
                                ]
                                right:<Op_DSemi ";;">
                              )
                              (CaseArm
                                left:<Lit_Chars dmesg>
                                pattern:(pat.Words
                                  words:[(w <Lit_Chars dmesg>)]
                                )
                                middle:<Right_CasePat ")">
                                action:[
                                  (command.ShAssignment
                                    left:<Lit_VarLike "options=">
                                    pairs:[
                                      (AssignPair
                                        left:...0x1e72
                                        lhs:(sh_lhs.Name
                                          left:...0x1e72
                                          name:options
                                        )
                                        op:assign_op.Equal
                                        rhs:(w (SQ --clear))
                                      )
                                    ]
                                  )
                                ]
                                right:<Op_DSemi ";;">
                              )
                              (CaseArm
                                left:<Lit_Chars list>
                                pattern:(pat.Words words:[(w <Lit_Chars list>)])
                                middle:<Right_CasePat ")">
                                action:[
                                  (command.ShAssignment
                                    left:<Lit_VarLike "options=">
                                    pairs:[
                                      (AssignPair
                                        left:...0x1dd6
                                        lhs:(sh_lhs.Name
                                          left:...0x1dd6
                                          name:options
                                        )
                                        op:assign_op.Equal
                                        rhs:(w (SQ --long))
                                      )
                                    ]
                                  )
                                ]
                                right:<Op_DSemi ";;">
                              )
                              (CaseArm
                                left:<Lit_Chars reboot>
                                pattern:(pat.Words
                                  words:[(w <Lit_Chars reboot>)]
                                )
                                middle:<Right_CasePat ")">
                                action:[
                                  (command.ShAssignment
                                    left:<Lit_VarLike "options=">
                                    pairs:[
                                      (AssignPair
                                        left:...0x1d3a
                                        lhs:(sh_lhs.Name
                                          left:...0x1d3a
                                          name:options
                                        )
                                        op:assign_op.Equal
                                        rhs:(w (SQ "-w -a"))
                                      )
                                    ]
                                  )
                                ]
                                right:<Op_DSemi ";;">
                              )
                              (CaseArm
                                left:<Lit_Chars shutdown>
                                pattern:(pat.Words
                                  words:[(w <Lit_Chars shutdown>)]
                                )
                                middle:<Right_CasePat ")">
                                action:[
                                  (command.ShAssignment
                                    left:<Lit_VarLike "options=">
                                    pairs:[
                                      (AssignPair
                                        left:...0x1c9e
                                        lhs:(sh_lhs.Name
                                          left:...0x1c9e
                                          name:options
                                        )
                                        op:assign_op.Equal
                                        rhs:(w (SQ "-w -a -R -H"))
                                      )
                                    ]
                                  )
                                ]
                                right:<Op_DSemi ";;">
                              )
                              (CaseArm
                                left:<Lit_Chars sched-credit>
                                pattern:(pat.Words
                                  words:[(w <Lit_Chars sched-credit>)]
                                )
                                middle:<Right_CasePat ")">
                                action:[
                                  (command.ShAssignment
                                    left:<Lit_VarLike "options=">
                                    pairs:[
                                      (AssignPair
                                        left:...0x1bfe
                                        lhs:(sh_lhs.Name
                                          left:...0x1bfe
                                          name:options
                                        )
                                        op:assign_op.Equal
                                        rhs:(w (SQ "-d -w -c"))
                                      )
                                    ]
                                  )
                                ]
                                right:<Op_DSemi ";;">
                              )
                              (CaseArm
                                left:<Lit_Chars block-list>
                                pattern:(pat.Words
                                  words:[
                                    (w <Lit_Chars block-list>)
                                    (w <Lit_Chars network-list>)
                                    (w <Lit_Chars vtpm-list>)
                                    (w <Lit_Chars vnet-list>)
                                  ]
                                )
                                middle:<Right_CasePat ")">
                                action:[
                                  (command.ShAssignment
                                    left:<Lit_VarLike "options=">
                                    pairs:[
                                      (AssignPair
                                        left:...0x1b2a
                                        lhs:(sh_lhs.Name
                                          left:...0x1b2a
                                          name:options
                                        )
                                        op:assign_op.Equal
                                        rhs:(w (SQ "-l --long"))
                                      )
                                    ]
                                  )
                                ]
                                right:<Op_DSemi ";;">
                              )
                              (CaseArm
                                left:<Lit_Chars getpolicy>
                                pattern:(pat.Words
                                  words:[(w <Lit_Chars getpolicy>)]
                                )
                                middle:<Right_CasePat ")">
                                action:[
                                  (command.ShAssignment
                                    left:<Lit_VarLike "options=">
                                    pairs:[
                                      (AssignPair
                                        left:...0x2532
                                        lhs:(sh_lhs.Name
                                          left:...0x2532
                                          name:options
                                        )
                                        op:assign_op.Equal
                                        rhs:(w (SQ --dumpxml))
                                      )
                                    ]
                                  )
                                ]
                                right:<Op_DSemi ";;">
                              )
                              (CaseArm
                                left:<Lit_Chars new>
                                pattern:(pat.Words words:[(w <Lit_Chars new>)])
                                middle:<Right_CasePat ")">
                                action:[
                                  (command.ShAssignment
                                    left:<Lit_VarLike "options=">
                                    pairs:[
                                      (AssignPair
                                        left:...0x2492
                                        lhs:(sh_lhs.Name
                                          left:...0x2492
                                          name:options
                                        )
                                        op:assign_op.Equal
                                        rhs:(w
                                          (SQ
                                            "-h --help --help_config -q --quiet --path= -f=\n                        --defconfig= -F= --config= -b --dryrun -x --xmldryrun\n                        -s --skipdtd -p --paused -c --console_autoconnect"
                                          )
                                        )
                                      )
                                    ]
                                  )
                                ]
                                right:<Op_DSemi ";;">
                              )
                            ]
                            arms_end:<KW_Esac esac>
                          )
                          (C
                            (w <Lit_Chars _comp_compgen>)
                            (w <Lit_Chars -->)
                            (w <Lit_Chars -W>)
                            (w (DQ ($ options)))
                          )
                        ]
                        then_tok:...0x1f96
                      )
                    ]
                    else_kw:<KW_Else else>
                    else_action:[
                      (command.Case
                        case_kw:<KW_Case case>
                        to_match:(case_arg.Word w:(w ($ command)))
                        arms_start:<KW_In in>
                        arms:[
                          (CaseArm
                            left:<Lit_Chars console>
                            pattern:(pat.Words
                              words:[
                                (w <Lit_Chars console>)
                                (w <Lit_Chars destroy>)
                                (w <Lit_Chars domname>)
                                (w <Lit_Chars domid>)
                                (w <Lit_Chars list>)
                                (w <Lit_Chars mem-set>)
                                (w <Lit_Chars mem-max>)
                                (w <Lit_Chars pause>)
                                (w <Lit_Chars reboot>)
                                (w <Lit_Chars rename>)
                                (w <Lit_Chars shutdown>)
                                (w <Lit_Chars unpause>)
                                (w <Lit_Chars vcpu-list>)
                                (w <Lit_Chars vcpu-pin>)
                                (w <Lit_Chars vcpu-set>)
                                (w <Lit_Chars block-list>)
                                (w <Lit_Chars network-list>)
                                (w <Lit_Chars vtpm-list>)
                              ]
                            )
                            middle:<Right_CasePat ")">
                            action:[
                              (C (w <Lit_Chars _comp_count_args>))
                              (command.Case
                                case_kw:<KW_Case case>
                                to_match:(case_arg.Word w:(w ($ REPLY)))
                                arms_start:<KW_In in>
                                arms:[
                                  (CaseArm
                                    left:<Lit_Number 2>
                                    pattern:(pat.Words
                                      words:[(w <Lit_Number 2>)]
                                    )
                                    middle:<Right_CasePat ")">
                                    action:[
                                      (C
                                        (w
                                          <Lit_Chars _comp_cmd_xm__domain_names>
                                        )
                                      )
                                    ]
                                    right:<Op_DSemi ";;">
                                  )
                                ]
                                arms_end:<KW_Esac esac>
                              )
                            ]
                            right:<Op_DSemi ";;">
                          )
                          (CaseArm
                            left:<Lit_Chars migrate>
                            pattern:(pat.Words words:[(w <Lit_Chars migrate>)])
                            middle:<Right_CasePat ")">
                            action:[
                              (C (w <Lit_Chars _comp_count_args>))
                              (command.Case
                                case_kw:<KW_Case case>
                                to_match:(case_arg.Word w:(w ($ REPLY)))
                                arms_start:<KW_In in>
                                arms:[
                                  (CaseArm
                                    left:<Lit_Number 2>
                                    pattern:(pat.Words
                                      words:[(w <Lit_Number 2>)]
                                    )
                                    middle:<Right_CasePat ")">
                                    action:[
                                      (C
                                        (w
                                          <Lit_Chars _comp_cmd_xm__domain_names>
                                        )
                                      )
                                    ]
                                    right:<Op_DSemi ";;">
                                  )
                                  (CaseArm
                                    left:<Lit_Number 3>
                                    pattern:(pat.Words
                                      words:[(w <Lit_Number 3>)]
                                    )
                                    middle:<Right_CasePat ")">
                                    action:[
                                      (C
                                        (w
                                          <Lit_Chars _comp_compgen_known_hosts>
                                        )
                                        (w <Lit_Chars -->)
                                        (w (DQ ($ cur)))
                                      )
                                    ]
                                    right:<Op_DSemi ";;">
                                  )
                                ]
                                arms_end:<KW_Esac esac>
                              )
                            ]
                            right:<Op_DSemi ";;">
                          )
                          (CaseArm
                            left:<Lit_Chars restore>
                            pattern:(pat.Words
                              words:[
                                (w <Lit_Chars restore>)
                                (w <Lit_Chars dry-run>)
                                (w <Lit_Chars vnet-create>)
                              ]
                            )
                            middle:<Right_CasePat ")">
                            action:[(C (w <Lit_Chars _comp_compgen_filedir>))]
                            right:<Op_DSemi ";;">
                          )
                          (CaseArm
                            left:<Lit_Chars save>
                            pattern:(pat.Words words:[(w <Lit_Chars save>)])
                            middle:<Right_CasePat ")">
                            action:[
                              (C (w <Lit_Chars _comp_count_args>))
                              (command.Case
                                case_kw:<KW_Case case>
                                to_match:(case_arg.Word w:(w ($ REPLY)))
                                arms_start:<KW_In in>
                                arms:[
                                  (CaseArm
                                    left:<Lit_Number 2>
                                    pattern:(pat.Words
                                      words:[(w <Lit_Number 2>)]
                                    )
                                    middle:<Right_CasePat ")">
                                    action:[
                                      (C
                                        (w
                                          <Lit_Chars _comp_cmd_xm__domain_names>
                                        )
                                      )
                                    ]
                                    right:<Op_DSemi ";;">
                                  )
                                  (CaseArm
                                    left:<Lit_Number 3>
                                    pattern:(pat.Words
                                      words:[(w <Lit_Number 3>)]
                                    )
                                    middle:<Right_CasePat ")">
                                    action:[
                                      (C (w <Lit_Chars _comp_compgen_filedir>))
                                    ]
                                    right:<Op_DSemi ";;">
                                  )
                                ]
                                arms_end:<KW_Esac esac>
                              )
                            ]
                            right:<Op_DSemi ";;">
                          )
                          (CaseArm
                            left:<Lit_Chars sysrq>
                            pattern:(pat.Words words:[(w <Lit_Chars sysrq>)])
                            middle:<Right_CasePat ")">
                            action:[
                              (C (w <Lit_Chars _comp_count_args>))
                              (command.Case
                                case_kw:<KW_Case case>
                                to_match:(case_arg.Word w:(w ($ REPLY)))
                                arms_start:<KW_In in>
                                arms:[
                                  (CaseArm
                                    left:<Lit_Number 2>
                                    pattern:(pat.Words
                                      words:[(w <Lit_Number 2>)]
                                    )
                                    middle:<Right_CasePat ")">
                                    action:[
                                      (C
                                        (w
                                          <Lit_Chars _comp_cmd_xm__domain_names>
                                        )
                                      )
                                    ]
                                    right:<Op_DSemi ";;">
                                  )
                                  (CaseArm
                                    left:<Lit_Number 3>
                                    pattern:(pat.Words
                                      words:[(w <Lit_Number 3>)]
                                    )
                                    middle:<Right_CasePat ")">
                                    action:[
                                      (C
                                        (w <Lit_Chars _comp_compgen>)
                                        (w <Lit_Chars -->)
                                        (w <Lit_Chars -W>)
                                        (w (DQ <Lit_Chars "r s e i u b">))
                                      )
                                    ]
                                    right:<Op_DSemi ";;">
                                  )
                                ]
                                arms_end:<KW_Esac esac>
                              )
                            ]
                            right:<Op_DSemi ";;">
                          )
                          (CaseArm
                            left:<Lit_Chars block-attach>
                            pattern:(pat.Words
                              words:[(w <Lit_Chars block-attach>)]
                            )
                            middle:<Right_CasePat ")">
                            action:[
                              (C (w <Lit_Chars _comp_count_args>))
                              (command.Case
                                case_kw:<KW_Case case>
                                to_match:(case_arg.Word w:(w ($ REPLY)))
                                arms_start:<KW_In in>
                                arms:[
                                  (CaseArm
                                    left:<Lit_Number 2>
                                    pattern:(pat.Words
                                      words:[(w <Lit_Number 2>)]
                                    )
                                    middle:<Right_CasePat ")">
                                    action:[
                                      (C
                                        (w
                                          <Lit_Chars _comp_cmd_xm__domain_names>
                                        )
                                      )
                                    ]
                                    right:<Op_DSemi ";;">
                                  )
                                  (CaseArm
                                    left:<Lit_Number 3>
                                    pattern:(pat.Words
                                      words:[(w <Lit_Number 3>)]
                                    )
                                    middle:<Right_CasePat ")">
                                    action:[
                                      (C
                                        (w <Lit_Chars _comp_compgen>)
                                        (w <Lit_Chars -->)
                                        (w <Lit_Chars -W>)
                                        (w (DQ <Lit_Chars "phy: file:">))
                                      )
                                    ]
                                    right:<Op_DSemi ";;">
                                  )
                                  (CaseArm
                                    left:<Lit_Number 5>
                                    pattern:(pat.Words
                                      words:[(w <Lit_Number 5>)]
                                    )
                                    middle:<Right_CasePat ")">
                                    action:[
                                      (C
                                        (w <Lit_Chars _comp_compgen>)
                                        (w <Lit_Chars -->)
                                        (w <Lit_Chars -W>)
                                        (w (DQ <Lit_Chars "w r">))
                                      )
                                    ]
                                    right:<Op_DSemi ";;">
                                  )
                                  (CaseArm
                                    left:<Lit_Number 6>
                                    pattern:(pat.Words
                                      words:[(w <Lit_Number 6>)]
                                    )
                                    middle:<Right_CasePat ")">
                                    action:[
                                      (C
                                        (w
                                          <Lit_Chars _comp_cmd_xm__domain_names>
                                        )
                                      )
                                    ]
                                    right:<Op_DSemi ";;">
                                  )
                                ]
                                arms_end:<KW_Esac esac>
                              )
                            ]
                            right:<Op_DSemi ";;">
                          )
                          (CaseArm
                            left:<Lit_Chars block-detach>
                            pattern:(pat.Words
                              words:[(w <Lit_Chars block-detach>)]
                            )
                            middle:<Right_CasePat ")">
                            action:[
                              (C (w <Lit_Chars _comp_count_args>))
                              (command.Case
                                case_kw:<KW_Case case>
                                to_match:(case_arg.Word w:(w ($ REPLY)))
                                arms_start:<KW_In in>
                                arms:[
                                  (CaseArm
                                    left:<Lit_Number 2>
                                    pattern:(pat.Words
                                      words:[(w <Lit_Number 2>)]
                                    )
                                    middle:<Right_CasePat ")">
                                    action:[
                                      (C
                                        (w
                                          <Lit_Chars _comp_cmd_xm__domain_names>
                                        )
                                      )
                                    ]
                                    right:<Op_DSemi ";;">
                                  )
                                  (CaseArm
                                    left:<Lit_Number 3>
                                    pattern:(pat.Words
                                      words:[(w <Lit_Number 3>)]
                                    )
                                    middle:<Right_CasePat ")">
                                    action:[
                                      (C
                                        (w <Lit_Chars _comp_compgen_split>)
                                        (w <Lit_Chars -->)
                                        (w
                                          (DQ
                                            (CommandSub
                                              left_token:<Left_DollarParen "$(">
                                              child:(command.Pipeline
                                                children:[
                                                  (C
                                                    (w <Lit_Chars xm>)
                                                    (w <Lit_Chars block-list>)
                                                    (w (DQ ($ prev)))
                                                  )
                                                  (C
                                                    (w <Lit_Chars _comp_awk>)
                                                    (w
                                                      (SQ
                                                        "!/Vdev/ { print $1 }"
                                                      )
                                                    )
                                                  )
                                                ]
                                                ops:[<Op_Pipe "|">]
                                              )
                                              right:<Eof_RParen ")">
                                            )
                                          )
                                        )
                                      )
                                    ]
                                    right:<Op_DSemi ";;">
                                  )
                                ]
                                arms_end:<KW_Esac esac>
                              )
                            ]
                            right:<Op_DSemi ";;">
                          )
                          (CaseArm
                            left:<Lit_Chars network-attach>
                            pattern:(pat.Words
                              words:[(w <Lit_Chars network-attach>)]
                            )
                            middle:<Right_CasePat ")">
                            action:[
                              (C (w <Lit_Chars _comp_count_args>))
                              (command.Case
                                case_kw:<KW_Case case>
                                to_match:(case_arg.Word w:(w ($ REPLY)))
                                arms_start:<KW_In in>
                                arms:[
                                  (CaseArm
                                    left:<Lit_Number 2>
                                    pattern:(pat.Words
                                      words:[(w <Lit_Number 2>)]
                                    )
                                    middle:<Right_CasePat ")">
                                    action:[
                                      (C
                                        (w
                                          <Lit_Chars _comp_cmd_xm__domain_names>
                                        )
                                      )
                                    ]
                                    right:<Op_DSemi ";;">
                                  )
                                  (CaseArm
                                    left:<Lit_Star "*">
                                    pattern:(pat.Words
                                      words:[(w <Lit_Star "*">)]
                                    )
                                    middle:<Right_CasePat ")">
                                    action:[
                                      (C
                                        (w <Lit_Chars _comp_compgen>)
                                        (w <Lit_Chars -->)
                                        (w <Lit_Chars -W>)
                                        (w
                                          (DQ
                                            <
                                              Lit_Chars
                                              "script= ip= mac= bridge=\n"
                                            >
                                            <
                                              Lit_Chars
                                              "                                backend="
                                            >
                                          )
                                        )
                                      )
                                    ]
                                    right:<Op_DSemi ";;">
                                  )
                                ]
                                arms_end:<KW_Esac esac>
                              )
                            ]
                            right:<Op_DSemi ";;">
                          )
                          (CaseArm
                            left:<Lit_Chars network-detach>
                            pattern:(pat.Words
                              words:[(w <Lit_Chars network-detach>)]
                            )
                            middle:<Right_CasePat ")">
                            action:[
                              (C (w <Lit_Chars _comp_count_args>))
                              (command.Case
                                case_kw:<KW_Case case>
                                to_match:(case_arg.Word w:(w ($ REPLY)))
                                arms_start:<KW_In in>
                                arms:[
                                  (CaseArm
                                    left:<Lit_Number 2>
                                    pattern:(pat.Words
                                      words:[(w <Lit_Number 2>)]
                                    )
                                    middle:<Right_CasePat ")">
                                    action:[
                                      (C
                                        (w
                                          <Lit_Chars _comp_cmd_xm__domain_names>
                                        )
                                      )
                                    ]
                                    right:<Op_DSemi ";;">
                                  )
                                  (CaseArm
                                    left:<Lit_Number 3>
                                    pattern:(pat.Words
                                      words:[(w <Lit_Number 3>)]
                                    )
                                    middle:<Right_CasePat ")">
                                    action:[
                                      (C
                                        (w <Lit_Chars _comp_compgen_split>)
                                        (w <Lit_Chars -->)
                                        (w
                                          (DQ
                                            (CommandSub
                                              left_token:<Left_DollarParen "$(">
                                              child:(command.Pipeline
                                                children:[
                                                  (C
                                                    (w <Lit_Chars xm>)
                                                    (w <Lit_Chars network-list>)
                                                    (w (DQ ($ prev)))
                                                  )
                                                  (C
                                                    (w <Lit_Chars _comp_awk>)
                                                    (w
                                                      (SQ "!/Idx/ { print $1 }")
                                                    )
                                                  )
                                                ]
                                                ops:[<Op_Pipe "|">]
                                              )
                                              right:<Eof_RParen ")">
                                            )
                                          )
                                        )
                                      )
                                    ]
                                    right:<Op_DSemi ";;">
                                  )
                                ]
                                arms_end:<KW_Esac esac>
                              )
                            ]
                            right:<Op_DSemi ";;">
                          )
                          (CaseArm
                            left:<Lit_Chars sched-credit>
                            pattern:(pat.Words
                              words:[(w <Lit_Chars sched-credit>)]
                            )
                            middle:<Right_CasePat ")">
                            action:[
                              (command.Case
                                case_kw:<KW_Case case>
                                to_match:(case_arg.Word w:(w ($ prev)))
                                arms_start:<KW_In in>
                                arms:[
                                  (CaseArm
                                    left:<Lit_Chars -d>
                                    pattern:(pat.Words
                                      words:[(w <Lit_Chars -d>)]
                                    )
                                    middle:<Right_CasePat ")">
                                    action:[
                                      (C
                                        (w
                                          <Lit_Chars _comp_cmd_xm__domain_names>
                                        )
                                      )
                                      (command.ControlFlow
                                        keyword:<ControlFlow_Return return>
                                      )
                                    ]
                                    right:<Op_DSemi ";;">
                                  )
                                ]
                                arms_end:<KW_Esac esac>
                              )
                            ]
                            right:<Op_DSemi ";;">
                          )
                          (CaseArm
                            left:<Lit_Chars create>
                            pattern:(pat.Words words:[(w <Lit_Chars create>)])
                            middle:<Right_CasePat ")">
                            action:[
                              (C (w <Lit_Chars _comp_compgen_filedir>))
                              (C
                                (w <Lit_Chars _comp_compgen>)
                                (w <Lit_Chars -a>)
                                (w <Lit_Chars split>)
                                (w <Lit_Chars -->)
                                (w
                                  (DQ
                                    (CommandSub
                                      left_token:<Left_DollarParen "$(">
                                      child:(C
                                        (w <Lit_Chars command>)
                                        (w <Lit_Chars ls>)
                                        (w
                                          <Lit_Slash />
                                          <Lit_Chars etc>
                                          <Lit_Slash />
                                          <Lit_Chars xen>
                                        )
                                      )
                                      right:<Eof_RParen ")">
                                    )
                                  )
                                )
                              )
                            ]
                            right:<Op_DSemi ";;">
                          )
                          (CaseArm
                            left:<Lit_Chars new>
                            pattern:(pat.Words words:[(w <Lit_Chars new>)])
                            middle:<Right_CasePat ")">
                            action:[
                              (command.Case
                                case_kw:<KW_Case case>
                                to_match:(case_arg.Word w:(w ($ prev)))
                                arms_start:<KW_In in>
                                arms:[
                                  (CaseArm
                                    left:<Lit_Chars -f>
                                    pattern:(pat.Words
                                      words:[
                                        (w <Lit_Chars -f>)
                                        (w <Lit_Chars -F>)
                                        (w <Lit_Chars --defconfig>)
                                        (w <Lit_Chars --config>)
                                      ]
                                    )
                                    middle:<Right_CasePat ")">
                                    action:[
                                      (C (w <Lit_Chars _comp_compgen_filedir>))
                                      (command.ControlFlow
                                        keyword:<ControlFlow_Return return>
                                      )
                                    ]
                                    right:<Op_DSemi ";;">
                                  )
                                  (CaseArm
                                    left:<Lit_Chars --path>
                                    pattern:(pat.Words
                                      words:[(w <Lit_Chars --path>)]
                                    )
                                    middle:<Right_CasePat ")">
                                    action:[
                                      (C
                                        (w <Lit_Chars _comp_compgen_filedir>)
                                        (w <Lit_Chars -d>)
                                      )
                                      (command.ControlFlow
                                        keyword:<ControlFlow_Return return>
                                      )
                                    ]
                                    right:<Op_DSemi ";;">
                                  )
                                ]
                                arms_end:<KW_Esac esac>
                              )
                              (C (w <Lit_Chars _comp_count_args>))
                              (command.Case
                                case_kw:<KW_Case case>
                                to_match:(case_arg.Word w:(w ($ REPLY)))
                                arms_start:<KW_In in>
                                arms:[
                                  (CaseArm
                                    left:<Lit_Number 2>
                                    pattern:(pat.Words
                                      words:[(w <Lit_Number 2>)]
                                    )
                                    middle:<Right_CasePat ")">
                                    action:[
                                      (C
                                        (w
                                          <Lit_Chars _comp_cmd_xm__domain_names>
                                        )
                                      )
                                    ]
                                    right:<Op_DSemi ";;">
                                  )
                                ]
                                arms_end:<KW_Esac esac>
                              )
                            ]
                            right:<Op_DSemi ";;">
                          )
                        ]
                        arms_end:<KW_Esac esac>
                      )
                    ]
                    fi_kw:<KW_Fi fi>
                  )
                ]
                fi_kw:<KW_Fi fi>
              )
            ]
            right:<Lit_RBrace "}">
          )
          code_str:"_comp_cmd_xm()\n{\n    local cur prev words cword comp_args\n    _comp_initialize -- \"$@\" || return\n\n    # TODO: split longopt\n\n    local REPLY command commands options\n\n    commands='console vncviewer create new delete destroy domid domname\n        dump-core list mem-max mem-set migrate pause reboot rename reset\n        restore resume save shutdown start suspend sysrq trigger top unpause\n        uptime usb-add usb-del vcpu-list vcpu-pin vcpu-set debug-keys dmesg\n        info log serve sched-credit sched-sedf block-attach block-detach\n        block-list block-configure network-attach network-detach network-list\n        vtpm-list pci-attach pci-detach pci-list pci-list-assignable-devices\n        scsi-attach scsi-detach scsi-list vnet-list vnet-create vnet-delete\n        labels addlabel rmlabel getlabel dry-run resources dumppolicy setpolicy\n        resetpolicy getpolicy shell help'\n\n    if ((cword == 1)); then\n        _comp_compgen -- -W \"$commands\"\n    else\n        if [[ $cur == *=* ]]; then\n            prev=${cur/=*/}\n            cur=${cur/*=/}\n        fi\n\n        command=${words[1]}\n        if [[ $cur == -* ]]; then\n            # possible options for the command\n            case $command in\n                create)\n                    options='-c'\n                    ;;\n                dmesg)\n                    options='--clear'\n                    ;;\n                list)\n                    options='--long'\n                    ;;\n                reboot)\n                    options='-w -a'\n                    ;;\n                shutdown)\n                    options='-w -a -R -H'\n                    ;;\n                sched-credit)\n                    options='-d -w -c'\n                    ;;\n                block-list | network-list | vtpm-list | vnet-list)\n                    options='-l --long'\n                    ;;\n                getpolicy)\n                    options='--dumpxml'\n                    ;;\n                new)\n                    options='-h --help --help_config -q --quiet --path= -f=\n                        --defconfig= -F= --config= -b --dryrun -x --xmldryrun\n                        -s --skipdtd -p --paused -c --console_autoconnect'\n                    ;;\n            esac\n            _comp_compgen -- -W \"$options\"\n        else\n            case $command in\n                console | destroy | domname | domid | list | mem-set | \\\n                    mem-max | pause | reboot | rename | shutdown | unpause | \\\n                    vcpu-list | vcpu-pin | vcpu-set | block-list | \\\n                    network-list | vtpm-list)\n                    _comp_count_args\n                    case $REPLY in\n                        2)\n                            _comp_cmd_xm__domain_names\n                            ;;\n                    esac\n                    ;;\n                migrate)\n                    _comp_count_args\n                    case $REPLY in\n                        2)\n                            _comp_cmd_xm__domain_names\n                            ;;\n                        3)\n                            _comp_compgen_known_hosts -- \"$cur\"\n                            ;;\n                    esac\n                    ;;\n                restore | dry-run | vnet-create)\n                    _comp_compgen_filedir\n                    ;;\n                save)\n                    _comp_count_args\n                    case $REPLY in\n                        2)\n                            _comp_cmd_xm__domain_names\n                            ;;\n                        3)\n                            _comp_compgen_filedir\n                            ;;\n                    esac\n                    ;;\n                sysrq)\n                    _comp_count_args\n                    case $REPLY in\n                        2)\n                            _comp_cmd_xm__domain_names\n                            ;;\n                        3)\n                            _comp_compgen -- -W \"r s e i u b\"\n                            ;;\n                    esac\n                    ;;\n                block-attach)\n                    _comp_count_args\n                    case $REPLY in\n                        2)\n                            _comp_cmd_xm__domain_names\n                            ;;\n                        3)\n                            _comp_compgen -- -W \"phy: file:\"\n                            ;;\n                        5)\n                            _comp_compgen -- -W \"w r\"\n                            ;;\n                        6)\n                            _comp_cmd_xm__domain_names\n                            ;;\n                    esac\n                    ;;\n                block-detach)\n                    _comp_count_args\n                    case $REPLY in\n                        2)\n                            _comp_cmd_xm__domain_names\n                            ;;\n                        3)\n                            _comp_compgen_split -- \"$(xm block-list \"$prev\" \\\n                                2>/dev/null | _comp_awk '!/Vdev/ { print $1 }')\"\n                            ;;\n                    esac\n                    ;;\n                network-attach)\n                    _comp_count_args\n                    case $REPLY in\n                        2)\n                            _comp_cmd_xm__domain_names\n                            ;;\n                        *)\n                            _comp_compgen -- -W \"script= ip= mac= bridge=\n                                backend=\"\n                            ;;\n                    esac\n                    ;;\n                network-detach)\n                    _comp_count_args\n                    case $REPLY in\n                        2)\n                            _comp_cmd_xm__domain_names\n                            ;;\n                        3)\n                            _comp_compgen_split -- \"$(xm network-list \"$prev\" \\\n                                2>/dev/null | _comp_awk '!/Idx/ { print $1 }')\"\n                            ;;\n                    esac\n                    ;;\n                sched-credit)\n                    case $prev in\n                        -d)\n                            _comp_cmd_xm__domain_names\n                            return\n                            ;;\n                    esac\n                    ;;\n                create)\n                    _comp_compgen_filedir\n                    _comp_compgen -a split -- \"$(\n                        command ls /etc/xen 2>/dev/null\n                    )\"\n                    ;;\n                new)\n                    case $prev in\n                        -f | -F | --defconfig | --config)\n                            _comp_compgen_filedir\n                            return\n                            ;;\n                        --path)\n                            _comp_compgen_filedir -d\n                            return\n                            ;;\n                    esac\n\n                    _comp_count_args\n                    case $REPLY in\n                        2)\n                            _comp_cmd_xm__domain_names\n                            ;;\n                    esac\n                    ;;\n            esac\n        fi\n    fi\n}"
        )
        (C
          (w <Lit_Chars complete>)
          (w <Lit_Chars -F>)
          (w <Lit_Chars _comp_cmd_xm>)
          (w <Lit_Chars xm>)
        )
      ]
      ops:[<Op_DAmp "&&">]
    )
  ]
)
(command.AndOr
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_xmllint>
      name:_comp_cmd_xmllint
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars cur>)
            (w <Lit_Chars prev>)
            (w <Lit_Chars words>)
            (w <Lit_Chars cword>)
            (w <Lit_Chars comp_args>)
          )
          (command.AndOr
            children:[
              (C
                (w <Lit_Chars _comp_initialize>)
                (w <Lit_Chars -->)
                (w (DQ ($ VSub_At)))
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DPipe "||">]
          )
          (command.Case
            case_kw:<KW_Case case>
            to_match:(case_arg.Word w:(w ($ prev)))
            arms_start:<KW_In in>
            arms:[
              (CaseArm
                left:<Lit_Chars -o>
                pattern:(pat.Words
                  words:[(w <Lit_Chars -o>) (w <Lit_Chars --output>)]
                )
                middle:<Right_CasePat ")">
                action:[
                  (C (w <Lit_Chars _comp_compgen_filedir>))
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --path>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --path>)
                    (w <Lit_Chars --dtdvalidfpi>)
                    (w <Lit_Chars --maxmem>)
                    (w <Lit_Chars --pattern>)
                    (w <Lit_Chars --xpath>)
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --dtdvalid>
                pattern:(pat.Words words:[(w <Lit_Chars --dtdvalid>)])
                middle:<Right_CasePat ")">
                action:[
                  (C (w <Lit_Chars _comp_compgen_filedir>) (w (SQ "dtd?(.gz)")))
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --relaxng>
                pattern:(pat.Words words:[(w <Lit_Chars --relaxng>)])
                middle:<Right_CasePat ")">
                action:[
                  (C (w <Lit_Chars _comp_compgen_filedir>) (w (SQ "rng?(.gz)")))
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --schema>
                pattern:(pat.Words words:[(w <Lit_Chars --schema>)])
                middle:<Right_CasePat ")">
                action:[
                  (C (w <Lit_Chars _comp_compgen_filedir>) (w (SQ "xsd?(.gz)")))
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --schematron>
                pattern:(pat.Words words:[(w <Lit_Chars --schematron>)])
                middle:<Right_CasePat ")">
                action:[
                  (C (w <Lit_Chars _comp_compgen_filedir>) (w (SQ "sch?(.gz)")))
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --encode>
                pattern:(pat.Words words:[(w <Lit_Chars --encode>)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -x>)
                    (w <Lit_Chars iconv>)
                    (w <Lit_Chars charsets>)
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --pretty>
                pattern:(pat.Words words:[(w <Lit_Chars --pretty>)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ "{0..2}"))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
            ]
            arms_end:<KW_Esac esac>
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x1f3a
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.Binary
                        op_id:BoolBinary_GlobDEqual
                        left:(w ($ cur))
                        right:(w <Lit_Chars -> <Lit_Other "*">)
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (C (w <Lit_Chars _comp_compgen_help>))
                  (command.ShAssignment
                    left:<Lit_VarLike "COMPREPLY=">
                    pairs:[
                      (AssignPair
                        left:...0x1e76
                        lhs:(sh_lhs.Name left:...0x1e76 name:COMPREPLY)
                        op:assign_op.Equal
                        rhs:(w
                          (word_part.InitializerLiteral
                            left:<Op_LParen "(">
                            pairs:[
                              (InitializerWord.ArrayWord
                                w:(w
                                  (DQ
                                    (BracedVarSub
                                      left:<Left_DollarBrace "${">
                                      name_tok:<VSub_Name COMPREPLY>
                                      var_name:COMPREPLY
                                      bracket_op:(bracket_op.WholeArray
                                        op_id:Lit_At
                                      )
                                      suffix_op:(suffix_op.Unary
                                        op:<VOp1_Percent "%">
                                        arg_word:(w <Lit_Chars ":">)
                                      )
                                      right:<Right_DollarBrace "}">
                                    )
                                  )
                                )
                              )
                            ]
                            right:<Right_Initializer ")">
                          )
                        )
                      )
                    ]
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                then_tok:...0x1ece
              )
            ]
            else_action:[]
            fi_kw:<KW_Fi fi>
          )
          (C
            (w <Lit_Chars _comp_compgen_filedir>)
            (w
              (SQ
                "@(*ml|htm|svg?(z)|xs[dl]|rng|wsdl|jnlp|tld|dbk|docbook|page|rss)?(.gz)"
              )
            )
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_xmllint()\n{\n    local cur prev words cword comp_args\n    _comp_initialize -- \"$@\" || return\n\n    case $prev in\n        -o | --output)\n            _comp_compgen_filedir\n            return\n            ;;\n        --path | --dtdvalidfpi | --maxmem | --pattern | --xpath)\n            # argument required but no completions available\n            return\n            ;;\n        --dtdvalid)\n            _comp_compgen_filedir 'dtd?(.gz)'\n            return\n            ;;\n        --relaxng)\n            _comp_compgen_filedir 'rng?(.gz)'\n            return\n            ;;\n        --schema)\n            _comp_compgen_filedir 'xsd?(.gz)'\n            return\n            ;;\n        --schematron)\n            _comp_compgen_filedir 'sch?(.gz)'\n            return\n            ;;\n        --encode)\n            _comp_compgen -x iconv charsets\n            return\n            ;;\n        --pretty)\n            _comp_compgen -- -W '{0..2}'\n            return\n            ;;\n    esac\n\n    if [[ $cur == -* ]]; then\n        _comp_compgen_help\n        COMPREPLY=(\"${COMPREPLY[@]%:}\")\n        return\n    fi\n\n    _comp_compgen_filedir '@(*ml|htm|svg?(z)|xs[dl]|rng|wsdl|jnlp|tld|dbk|docbook|page|rss)?(.gz)'\n}"
    )
    (C
      (w <Lit_Chars complete>)
      (w <Lit_Chars -F>)
      (w <Lit_Chars _comp_cmd_xmllint>)
      (w <Lit_Chars xmllint>)
    )
  ]
  ops:[<Op_DAmp "&&">]
)
(command.AndOr
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_xmlwf>
      name:_comp_cmd_xmlwf
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars cur>)
            (w <Lit_Chars prev>)
            (w <Lit_Chars words>)
            (w <Lit_Chars cword>)
            (w <Lit_Chars comp_args>)
          )
          (command.AndOr
            children:[
              (C
                (w <Lit_Chars _comp_initialize>)
                (w <Lit_Chars -->)
                (w (DQ ($ VSub_At)))
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DPipe "||">]
          )
          (command.Case
            case_kw:<KW_Case case>
            to_match:(case_arg.Word w:(w ($ prev)))
            arms_start:<KW_In in>
            arms:[
              (CaseArm
                left:<Lit_Chars ->
                pattern:(pat.Words
                  words:[(w <Lit_Chars -> <Lit_Star "*"> <Lit_Chars d>)]
                )
                middle:<Right_CasePat ")">
                action:[
                  (C (w <Lit_Chars _comp_compgen_filedir>) (w <Lit_Chars -d>))
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars ->
                pattern:(pat.Words
                  words:[(w <Lit_Chars -> <Lit_Star "*"> <Lit_Chars e>)]
                )
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ "US-ASCII UTF-8 UTF-16 ISO-8859-1"))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars ->
                pattern:(pat.Words
                  words:[
                    (w
                      <Lit_Chars ->
                      <Lit_Star "*">
                      <Lit_LBracket "[">
                      <Lit_Chars abv>
                      <Lit_RBracket "]">
                    )
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
            ]
            arms_end:<KW_Esac esac>
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x18ce
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.Binary
                        op_id:BoolBinary_GlobDEqual
                        left:(w ($ cur))
                        right:(w <Lit_Chars -> <Lit_Other "*">)
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (command.AndOr
                    children:[
                      (C (w <Lit_Chars _comp_compgen_help>))
                      (C (w <Lit_Chars _comp_compgen_usage>))
                    ]
                    ops:[<Op_DPipe "||">]
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                then_tok:...0x1862
              )
            ]
            else_action:[]
            fi_kw:<KW_Fi fi>
          )
          (C
            (w <Lit_Chars _comp_compgen_filedir>)
            (w
              (SQ
                "@(*ml|htm|svg|xs[dl]|rng|wsdl|jnlp|tld|dbk|docbook|page|rss)"
              )
            )
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_xmlwf()\n{\n    local cur prev words cword comp_args\n    _comp_initialize -- \"$@\" || return\n\n    case $prev in\n        -*d)\n            _comp_compgen_filedir -d\n            return\n            ;;\n        -*e)\n            _comp_compgen -- -W 'US-ASCII UTF-8 UTF-16 ISO-8859-1'\n            return\n            ;;\n        -*[abv])\n            return\n            ;;\n    esac\n\n    if [[ $cur == -* ]]; then\n        _comp_compgen_help || _comp_compgen_usage\n        return\n    fi\n\n    _comp_compgen_filedir '@(*ml|htm|svg|xs[dl]|rng|wsdl|jnlp|tld|dbk|docbook|page|rss)'\n}"
    )
    (C
      (w <Lit_Chars complete>)
      (w <Lit_Chars -F>)
      (w <Lit_Chars _comp_cmd_xmlwf>)
      (w <Lit_Chars xmlwf>)
    )
  ]
  ops:[<Op_DAmp "&&">]
)
(command.AndOr
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_xmms>
      name:_comp_cmd_xmms
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars cur>)
            (w <Lit_Chars prev>)
            (w <Lit_Chars words>)
            (w <Lit_Chars cword>)
            (w <Lit_Chars was_split>)
            (w <Lit_Chars comp_args>)
          )
          (command.AndOr
            children:[
              (C
                (w <Lit_Chars _comp_initialize>)
                (w <Lit_Chars -s>)
                (w <Lit_Chars -->)
                (w (DQ ($ VSub_At)))
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DPipe "||">]
          )
          (C
            (w <Lit_Chars local>)
            (w <Lit_VarLike "noargopts="> (SQ "!(-*|*[SRA]*)"))
          )
          (command.Case
            case_kw:<KW_Case case>
            to_match:(case_arg.Word w:(w ($ prev)))
            arms_start:<KW_In in>
            arms:[
              (CaseArm
                left:<Lit_Chars --help>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --help>)
                    (w <Lit_Chars --version>)
                    (w
                      <Lit_Chars ->
                      (${ VSub_Name noargopts)
                      <Lit_LBracket "[">
                      <Lit_Chars hv>
                      <Lit_RBracket "]">
                    )
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --toggle-shuffle>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --toggle-shuffle>)
                    (w <Lit_Chars --toggle-repeat>)
                    (w <Lit_Chars --toggle-advance>)
                    (w
                      <Lit_Chars ->
                      (${ VSub_Name noargopts)
                      <Lit_LBracket "[">
                      <Lit_Chars SRA>
                      <Lit_RBracket "]">
                    )
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ "on off"))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
            ]
            arms_end:<KW_Esac esac>
          )
          (command.AndOr
            children:[
              (command.DBracket
                left:<KW_DLeftBracket "[[">
                expr:(bool_expr.WordTest w:(w ($ was_split)))
                right:<Lit_DRightBracket "]]">
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DAmp "&&">]
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x1816
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.Binary
                        op_id:BoolBinary_GlobDEqual
                        left:(w ($ cur))
                        right:(w <Lit_Chars -> <Lit_Other "*">)
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[(C (w <Lit_Chars _comp_compgen_help>))]
                then_tok:...0x17aa
              )
            ]
            else_kw:<KW_Else else>
            else_action:[
              (C
                (w <Lit_Chars _comp_compgen_filedir>)
                (w
                  (SQ "@(mp[23]|ogg|wav|pls|m3u|xm|mod|s[3t]m|it|mtm|ult|flac)")
                )
              )
            ]
            fi_kw:<KW_Fi fi>
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_xmms()\n{\n    local cur prev words cword was_split comp_args\n    _comp_initialize -s -- \"$@\" || return\n\n    local noargopts='!(-*|*[SRA]*)'\n    # shellcheck disable=SC2254\n    case $prev in\n        --help | --version | -${noargopts}[hv])\n            return\n            ;;\n        --toggle-shuffle | --toggle-repeat | --toggle-advance | -${noargopts}[SRA])\n            _comp_compgen -- -W 'on off'\n            return\n            ;;\n    esac\n\n    [[ $was_split ]] && return\n\n    if [[ $cur == -* ]]; then\n        _comp_compgen_help\n    else\n        _comp_compgen_filedir '@(mp[23]|ogg|wav|pls|m3u|xm|mod|s[3t]m|it|mtm|ult|flac)'\n    fi\n\n}"
    )
    (C
      (w <Lit_Chars complete>)
      (w <Lit_Chars -F>)
      (w <Lit_Chars _comp_cmd_xmms>)
      (w <Lit_Chars xmms>)
    )
  ]
  ops:[<Op_DAmp "&&">]
)
(command.AndOr
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_xmodmap>
      name:_comp_cmd_xmodmap
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars cur>)
            (w <Lit_Chars prev>)
            (w <Lit_Chars words>)
            (w <Lit_Chars cword>)
            (w <Lit_Chars comp_args>)
          )
          (command.AndOr
            children:[
              (C
                (w <Lit_Chars _comp_initialize>)
                (w <Lit_Chars -->)
                (w (DQ ($ VSub_At)))
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DPipe "||">]
          )
          (command.Case
            case_kw:<KW_Case case>
            to_match:(case_arg.Word w:(w ($ prev)))
            arms_start:<KW_In in>
            arms:[
              (CaseArm
                left:<Lit_Chars -display>
                pattern:(pat.Words
                  words:[(w <Lit_Chars -display>) (w <Lit_Chars -e>)]
                )
                middle:<Right_CasePat ")">
                action:[
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
            ]
            arms_end:<KW_Esac esac>
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x1a6a
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.Binary
                        op_id:BoolBinary_GlobDEqual
                        left:(w ($ cur))
                        right:(w <Lit_Chars -> <Lit_Other "*">)
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen_help>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -help>)
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                then_tok:...0x19fe
              )
            ]
            else_action:[]
            fi_kw:<KW_Fi fi>
          )
          (C (w <Lit_Chars _comp_compgen_filedir>))
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_xmodmap()\n{\n    local cur prev words cword comp_args\n    _comp_initialize -- \"$@\" || return\n\n    case $prev in\n        -display | -e)\n            return\n            ;;\n    esac\n\n    if [[ $cur == -* ]]; then\n        _comp_compgen_help -- -help\n        return\n    fi\n\n    _comp_compgen_filedir\n}"
    )
    (C
      (w <Lit_Chars complete>)
      (w <Lit_Chars -F>)
      (w <Lit_Chars _comp_cmd_xmodmap>)
      (w <Lit_Chars xmodmap>)
    )
  ]
  ops:[<Op_DAmp "&&">]
)
(command.CommandList
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_xrandr__compgen_outputs>
      name:_comp_cmd_xrandr__compgen_outputs
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars _comp_compgen_split>)
            (w <Lit_Chars -->)
            (w
              (DQ
                (CommandSub
                  left_token:<Left_DollarParen "$(">
                  child:(command.Pipeline
                    children:[
                      (C (w (DQ ($ 1))) (w <Lit_Chars -q>))
                      (C
                        (w <Lit_Chars _comp_awk>)
                        (w (SQ "/connected/ {print $1}"))
                      )
                    ]
                    ops:[<Op_Pipe "|">]
                  )
                  right:<Eof_RParen ")">
                )
              )
            )
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_xrandr__compgen_outputs()\n{\n    _comp_compgen_split -- \"$(\"$1\" -q 2>/dev/null | _comp_awk '/connected/ {print $1}')\"\n}"
    )
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_xrandr__compgen_monitors>
      name:_comp_cmd_xrandr__compgen_monitors
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars _comp_compgen_split>)
            (w <Lit_Chars -->)
            (w
              (DQ
                (CommandSub
                  left_token:<Left_DollarParen "$(">
                  child:(command.Pipeline
                    children:[
                      (C (w (DQ ($ 1))) (w <Lit_Chars --listmonitors>))
                      (C
                        (w <Lit_Chars command>)
                        (w <Lit_Chars sed>)
                        (w <Lit_Chars -ne>)
                        (w (SQ "s/.* [0-9]*: [+\\*]*\\([^ ]*\\).*/\\1/p"))
                      )
                    ]
                    ops:[<Op_Pipe "|">]
                  )
                  right:<Eof_RParen ")">
                )
              )
            )
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_xrandr__compgen_monitors()\n{\n    _comp_compgen_split -- \"$(\n        \"$1\" --listmonitors 2>/dev/null |\n            command sed -ne 's/.* [0-9]*: [+\\*]*\\([^ ]*\\).*/\\1/p'\n    )\"\n}"
    )
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_xrandr__compgen_providers>
      name:_comp_cmd_xrandr__compgen_providers
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars _comp_compgen_split>)
            (w <Lit_Chars -->)
            (w
              (DQ
                (CommandSub
                  left_token:<Left_DollarParen "$(">
                  child:(command.Pipeline
                    children:[
                      (C (w (DQ ($ 1))) (w <Lit_Chars --listproviders>))
                      (C
                        (w <Lit_Chars command>)
                        (w <Lit_Chars sed>)
                        (w <Lit_Chars -ne>)
                        (w
                          (DQ
                            <Lit_Chars "s/.*cap:.*">
                            ($ 2)
                            <Lit_Chars ".* name:">
                            <Lit_BadBackslash "\\">
                            <Lit_Chars "([^ ]*">
                            <Lit_BadBackslash "\\">
                            <Lit_Chars ").*/">
                            <Lit_BadBackslash "\\">
                            <Lit_Chars 1/p>
                          )
                        )
                      )
                    ]
                    ops:[<Op_Pipe "|">]
                  )
                  right:<Eof_RParen ")">
                )
              )
            )
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_xrandr__compgen_providers()\n{\n    _comp_compgen_split -- \"$(\"$1\" --listproviders 2>/dev/null |\n        command sed -ne \"s/.*cap:.*$2.* name:\\([^ ]*\\).*/\\1/p\")\"\n}"
    )
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_xrandr__compgen_modes>
      name:_comp_cmd_xrandr__compgen_modes
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars _comp_compgen_split>)
            (w <Lit_Chars -->)
            (w
              (DQ
                (CommandSub
                  left_token:<Left_DollarParen "$(">
                  child:(command.Pipeline
                    children:[
                      (C (w (DQ ($ 1))) (w <Lit_Chars -q>))
                      (C
                        (w <Lit_Chars command>)
                        (w <Lit_Chars sed>)
                        (w <Lit_Chars -e>)
                        (w (DQ <Lit_Chars "1,/^"> ($ 2) <Lit_Chars " / d">))
                        (w <Lit_Chars -e>)
                        (w (SQ "/connected/,$ d"))
                        (w <Lit_Chars -e>)
                        (w (SQ "/^[[:space:]]*h: / d"))
                        (w <Lit_Chars -e>)
                        (w (SQ "/^[[:space:]]*v: / d"))
                        (w <Lit_Chars -e>)
                        (w (SQ "s/\\([^[:space:]]\\)[[:space:]].*/\\1/"))
                      )
                    ]
                    ops:[<Op_Pipe "|">]
                  )
                  right:<Eof_RParen ")">
                )
              )
            )
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_xrandr__compgen_modes()\n{\n    _comp_compgen_split -- \"$(\n        \"$1\" -q 2>/dev/null | command sed \\\n            -e \"1,/^$2 / d\" \\\n            -e '/connected/,$ d' \\\n            -e '/^[[:space:]]*h: / d' \\\n            -e '/^[[:space:]]*v: / d' \\\n            -e 's/\\([^[:space:]]\\)[[:space:]].*/\\1/'\n    )\"\n}"
    )
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_xrandr__compgen_all_modes>
      name:_comp_cmd_xrandr__compgen_all_modes
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars _comp_compgen_split>)
            (w <Lit_Chars -->)
            (w
              (DQ
                (CommandSub
                  left_token:<Left_DollarParen "$(">
                  child:(command.Pipeline
                    children:[
                      (C (w (DQ ($ 1))) (w <Lit_Chars -q>))
                      (C
                        (w <Lit_Chars command>)
                        (w <Lit_Chars sed>)
                        (w <Lit_Chars -e>)
                        (w (SQ "/^[^[:space:]].*/ d"))
                        (w <Lit_Chars -e>)
                        (w (SQ "/^[[:space:]]*h: / d"))
                        (w <Lit_Chars -e>)
                        (w (SQ "/^[[:space:]]*v: / d"))
                        (w <Lit_Chars -e>)
                        (w
                          (SQ
                            "s/[[:space:]]*\\([^[:space:]]*\\)[[:space:]].*/\\1/"
                          )
                        )
                      )
                    ]
                    ops:[<Op_Pipe "|">]
                  )
                  right:<Eof_RParen ")">
                )
              )
            )
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_xrandr__compgen_all_modes()\n{\n    _comp_compgen_split -- \"$(\n        \"$1\" -q 2>/dev/null | command sed \\\n            -e '/^[^[:space:]].*/ d' \\\n            -e '/^[[:space:]]*h: / d' \\\n            -e '/^[[:space:]]*v: / d' \\\n            -e 's/[[:space:]]*\\([^[:space:]]*\\)[[:space:]].*/\\1/'\n    )\"\n}"
    )
    (command.AndOr
      children:[
        (ShFunction
          name_tok:<Lit_Chars _comp_cmd_xrandr>
          name:_comp_cmd_xrandr
          body:(BraceGroup
            left:<Lit_LBrace "{">
            children:[
              (C
                (w <Lit_Chars local>)
                (w <Lit_Chars cur>)
                (w <Lit_Chars prev>)
                (w <Lit_Chars words>)
                (w <Lit_Chars cword>)
                (w <Lit_Chars comp_args>)
              )
              (command.AndOr
                children:[
                  (C
                    (w <Lit_Chars _comp_initialize>)
                    (w <Lit_Chars -->)
                    (w (DQ ($ VSub_At)))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                ops:[<Op_DPipe "||">]
              )
              (C
                (w <Lit_Chars local>)
                (w <Lit_Chars i>)
                (w <Lit_Chars output>)
                (w <Lit_VarLike "has_output="> (DQ))
              )
              (command.ForExpr
                keyword:<KW_For for>
                init:(arith_expr.BinaryAssign
                  op_id:Arith_Equal
                  left:<Lit_ArithVarLike i>
                  right:(arith_expr.Binary
                    op:<Arith_Minus ->
                    left:<Lit_ArithVarLike cword>
                    right:(w <Lit_Digits 1>)
                  )
                )
                cond:(arith_expr.Binary
                  op:<Arith_Great ">">
                  left:<Lit_ArithVarLike i>
                  right:(w <Lit_Digits 0>)
                )
                update:(arith_expr.UnaryAssign
                  op_id:Node_PostDMinus
                  child:<Lit_ArithVarLike i>
                )
                body:(command.DoGroup
                  left:<KW_Do do>
                  children:[
                    (command.If
                      if_kw:<KW_If if>
                      arms:[
                        (IfArm
                          keyword:...0x24ba
                          cond:[
                            (command.Sentence
                              child:(command.DBracket
                                left:<KW_DLeftBracket "[[">
                                expr:(bool_expr.Binary
                                  op_id:BoolBinary_GlobDEqual
                                  left:(w
                                    (BracedVarSub
                                      left:<Left_DollarBrace "${">
                                      name_tok:<VSub_Name words>
                                      var_name:words
                                      bracket_op:(bracket_op.ArrayIndex
                                        expr:<Lit_ArithVarLike i>
                                      )
                                      right:<Right_DollarBrace "}">
                                    )
                                  )
                                  right:(w <Lit_Chars --output>)
                                )
                                right:<Lit_DRightBracket "]]">
                              )
                              terminator:<Op_Semi ";">
                            )
                          ]
                          then_kw:<KW_Then then>
                          action:[
                            (command.ShAssignment
                              left:<Lit_VarLike "output=">
                              pairs:[
                                (AssignPair
                                  left:...0x241e
                                  lhs:(sh_lhs.Name left:...0x241e name:output)
                                  op:assign_op.Equal
                                  rhs:(w
                                    (BracedVarSub
                                      left:<Left_DollarBrace "${">
                                      name_tok:<VSub_Name words>
                                      var_name:words
                                      bracket_op:(bracket_op.ArrayIndex
                                        expr:(arith_expr.Binary
                                          op:<Arith_Plus "+">
                                          left:<Lit_ArithVarLike i>
                                          right:(w <Lit_Digits 1>)
                                        )
                                      )
                                      right:<Right_DollarBrace "}">
                                    )
                                  )
                                )
                              ]
                            )
                            (command.ShAssignment
                              left:<Lit_VarLike "has_output=">
                              pairs:[
                                (AssignPair
                                  left:...0x23b2
                                  lhs:(sh_lhs.Name
                                    left:...0x23b2
                                    name:has_output
                                  )
                                  op:assign_op.Equal
                                  rhs:(w <Lit_Chars set>)
                                )
                              ]
                            )
                            (command.ControlFlow
                              keyword:<ControlFlow_Break break>
                            )
                          ]
                          then_tok:...0x243a
                        )
                      ]
                      else_action:[]
                      fi_kw:<KW_Fi fi>
                    )
                  ]
                  right:<KW_Done done>
                )
              )
              (command.Case
                case_kw:<KW_Case case>
                to_match:(case_arg.Word w:(w (DQ ($ prev))))
                arms_start:<KW_In in>
                arms:[
                  (CaseArm
                    left:<Lit_Chars -display>
                    pattern:(pat.Words
                      words:[
                        (w <Lit_Chars -display>)
                        (w <Lit_Chars -d>)
                        (w <Lit_Chars -s>)
                        (w <Lit_Chars --size>)
                        (w <Lit_Chars -r>)
                        (w <Lit_Chars --rate>)
                        (w <Lit_Chars --refresh>)
                        (w <Lit_Chars --screen>)
                        (w <Lit_Chars --fb>)
                        (w <Lit_Chars --fbmm>)
                        (w <Lit_Chars --pos>)
                        (w <Lit_Chars --set>)
                        (w <Lit_Chars --scale>)
                        (w <Lit_Chars --transform>)
                        (w <Lit_Chars --crtc>)
                        (w <Lit_Chars --panning>)
                        (w <Lit_Chars --gamma>)
                        (w <Lit_Chars --newmode>)
                        (w <Lit_Chars --rmmode>)
                        (w <Lit_Chars --setmonitor>)
                      ]
                    )
                    middle:<Right_CasePat ")">
                    action:[
                      (command.ControlFlow keyword:<ControlFlow_Return return>)
                    ]
                    right:<Op_DSemi ";;">
                  )
                  (CaseArm
                    left:<Lit_Chars --output>
                    pattern:(pat.Words
                      words:[
                        (w <Lit_Chars --output>)
                        (w <Lit_Chars --addmode>)
                        (w <Lit_Chars --delmode>)
                        (w <Lit_Chars --dpi>)
                      ]
                    )
                    middle:<Right_CasePat ")">
                    action:[
                      (C
                        (w <Lit_Chars _comp_cmd_xrandr__compgen_outputs>)
                        (w (DQ ($ 1)))
                      )
                      (command.ControlFlow keyword:<ControlFlow_Return return>)
                    ]
                    right:<Op_DSemi ";;">
                  )
                  (CaseArm
                    left:<Lit_Chars --left-of>
                    pattern:(pat.Words
                      words:[
                        (w <Lit_Chars --left-of>)
                        (w <Lit_Chars --right-of>)
                        (w <Lit_Chars --above>)
                        (w <Lit_Chars --below>)
                        (w <Lit_Chars --same-as>)
                      ]
                    )
                    middle:<Right_CasePat ")">
                    action:[
                      (command.If
                        if_kw:<KW_If if>
                        arms:[
                          (IfArm
                            keyword:...0x2a06
                            cond:[
                              (command.Sentence
                                child:(command.DBracket
                                  left:<KW_DLeftBracket "[[">
                                  expr:(bool_expr.WordTest w:(w ($ has_output)))
                                  right:<Lit_DRightBracket "]]">
                                )
                                terminator:<Op_Semi ";">
                              )
                            ]
                            then_kw:<KW_Then then>
                            action:[
                              (C
                                (w
                                  <Lit_Chars _comp_cmd_xrandr__compgen_outputs>
                                )
                                (w (DQ ($ 1)))
                              )
                            ]
                            then_tok:...0x29b6
                          )
                        ]
                        else_action:[]
                        fi_kw:<KW_Fi fi>
                      )
                      (command.ControlFlow keyword:<ControlFlow_Return return>)
                    ]
                    right:<Op_DSemi ";;">
                  )
                  (CaseArm
                    left:<Lit_Chars --mode>
                    pattern:(pat.Words words:[(w <Lit_Chars --mode>)])
                    middle:<Right_CasePat ")">
                    action:[
                      (command.If
                        if_kw:<KW_If if>
                        arms:[
                          (IfArm
                            keyword:...0x28be
                            cond:[
                              (command.Sentence
                                child:(command.DBracket
                                  left:<KW_DLeftBracket "[[">
                                  expr:(bool_expr.WordTest w:(w ($ has_output)))
                                  right:<Lit_DRightBracket "]]">
                                )
                                terminator:<Op_Semi ";">
                              )
                            ]
                            then_kw:<KW_Then then>
                            action:[
                              (C
                                (w <Lit_Chars _comp_cmd_xrandr__compgen_modes>)
                                (w (DQ ($ 1)))
                                (w (DQ ($ output)))
                              )
                            ]
                            then_tok:...0x286e
                          )
                        ]
                        else_action:[]
                        fi_kw:<KW_Fi fi>
                      )
                      (command.ControlFlow keyword:<ControlFlow_Return return>)
                    ]
                    right:<Op_DSemi ";;">
                  )
                  (CaseArm
                    left:<Lit_Chars -o>
                    pattern:(pat.Words
                      words:[(w <Lit_Chars -o>) (w <Lit_Chars --orientation>)]
                    )
                    middle:<Right_CasePat ")">
                    action:[
                      (C
                        (w <Lit_Chars _comp_compgen>)
                        (w <Lit_Chars -->)
                        (w <Lit_Chars -W>)
                        (w (SQ "normal inverted left right 0 1 2 3"))
                      )
                      (command.ControlFlow keyword:<ControlFlow_Return return>)
                    ]
                    right:<Op_DSemi ";;">
                  )
                  (CaseArm
                    left:<Lit_Chars --reflect>
                    pattern:(pat.Words words:[(w <Lit_Chars --reflect>)])
                    middle:<Right_CasePat ")">
                    action:[
                      (command.If
                        if_kw:<KW_If if>
                        arms:[
                          (IfArm
                            keyword:...0x2662
                            cond:[
                              (command.Sentence
                                child:(command.DBracket
                                  left:<KW_DLeftBracket "[[">
                                  expr:(bool_expr.WordTest w:(w ($ has_output)))
                                  right:<Lit_DRightBracket "]]">
                                )
                                terminator:<Op_Semi ";">
                              )
                            ]
                            then_kw:<KW_Then then>
                            action:[
                              (C
                                (w <Lit_Chars _comp_compgen>)
                                (w <Lit_Chars -->)
                                (w <Lit_Chars -W>)
                                (w (SQ "normal x y xy"))
                              )
                            ]
                            then_tok:...0x2612
                          )
                        ]
                        else_action:[]
                        fi_kw:<KW_Fi fi>
                      )
                      (command.ControlFlow keyword:<ControlFlow_Return return>)
                    ]
                    right:<Op_DSemi ";;">
                  )
                  (CaseArm
                    left:<Lit_Chars --rotate>
                    pattern:(pat.Words words:[(w <Lit_Chars --rotate>)])
                    middle:<Right_CasePat ")">
                    action:[
                      (command.If
                        if_kw:<KW_If if>
                        arms:[
                          (IfArm
                            keyword:...0x2f96
                            cond:[
                              (command.Sentence
                                child:(command.DBracket
                                  left:<KW_DLeftBracket "[[">
                                  expr:(bool_expr.WordTest w:(w ($ has_output)))
                                  right:<Lit_DRightBracket "]]">
                                )
                                terminator:<Op_Semi ";">
                              )
                            ]
                            then_kw:<KW_Then then>
                            action:[
                              (C
                                (w <Lit_Chars _comp_compgen>)
                                (w <Lit_Chars -->)
                                (w <Lit_Chars -W>)
                                (w (SQ "normal inverted left right"))
                              )
                            ]
                            then_tok:...0x2f46
                          )
                        ]
                        else_action:[]
                        fi_kw:<KW_Fi fi>
                      )
                      (command.ControlFlow keyword:<ControlFlow_Return return>)
                    ]
                    right:<Op_DSemi ";;">
                  )
                  (CaseArm
                    left:<Lit_Chars --filter>
                    pattern:(pat.Words words:[(w <Lit_Chars --filter>)])
                    middle:<Right_CasePat ")">
                    action:[
                      (command.If
                        if_kw:<KW_If if>
                        arms:[
                          (IfArm
                            keyword:...0x2e22
                            cond:[
                              (command.Sentence
                                child:(command.DBracket
                                  left:<KW_DLeftBracket "[[">
                                  expr:(bool_expr.WordTest w:(w ($ has_output)))
                                  right:<Lit_DRightBracket "]]">
                                )
                                terminator:<Op_Semi ";">
                              )
                            ]
                            then_kw:<KW_Then then>
                            action:[
                              (C
                                (w <Lit_Chars _comp_compgen>)
                                (w <Lit_Chars -->)
                                (w <Lit_Chars -W>)
                                (w (SQ "bilinear nearest"))
                              )
                            ]
                            then_tok:...0x2dd2
                          )
                        ]
                        else_action:[]
                        fi_kw:<KW_Fi fi>
                      )
                      (command.ControlFlow keyword:<ControlFlow_Return return>)
                    ]
                    right:<Op_DSemi ";;">
                  )
                  (CaseArm
                    left:<Lit_Chars --setprovideroutputsource>
                    pattern:(pat.Words
                      words:[(w <Lit_Chars --setprovideroutputsource>)]
                    )
                    middle:<Right_CasePat ")">
                    action:[
                      (C
                        (w <Lit_Chars _comp_cmd_xrandr__compgen_providers>)
                        (w (DQ ($ 1)))
                        (w (DQ <Lit_Chars "Sink Output">))
                      )
                      (command.ControlFlow keyword:<ControlFlow_Return return>)
                    ]
                    right:<Op_DSemi ";;">
                  )
                  (CaseArm
                    left:<Lit_Chars --setprovideroffloadsink>
                    pattern:(pat.Words
                      words:[(w <Lit_Chars --setprovideroffloadsink>)]
                    )
                    middle:<Right_CasePat ")">
                    action:[
                      (C
                        (w <Lit_Chars _comp_cmd_xrandr__compgen_providers>)
                        (w (DQ ($ 1)))
                        (w (DQ <Lit_Chars "Source Offload">))
                      )
                      (command.ControlFlow keyword:<ControlFlow_Return return>)
                    ]
                    right:<Op_DSemi ";;">
                  )
                  (CaseArm
                    left:<Lit_Chars --delmonitor>
                    pattern:(pat.Words words:[(w <Lit_Chars --delmonitor>)])
                    middle:<Right_CasePat ")">
                    action:[
                      (C
                        (w <Lit_Chars _comp_cmd_xrandr__compgen_monitors>)
                        (w (DQ ($ 1)))
                      )
                      (command.ControlFlow keyword:<ControlFlow_Return return>)
                    ]
                    right:<Op_DSemi ";;">
                  )
                ]
                arms_end:<KW_Esac esac>
              )
              (command.If
                if_kw:<KW_If if>
                arms:[
                  (IfArm
                    keyword:...0x34de
                    cond:[
                      (command.Sentence
                        child:(command.DParen
                          left:<Op_DLeftParen "((">
                          child:(arith_expr.Binary
                            op:<Arith_GreatEqual ">=">
                            left:<Lit_ArithVarLike cword>
                            right:(w <Lit_Digits 2>)
                          )
                          right:<Op_DRightParen ")">
                        )
                        terminator:<Op_Semi ";">
                      )
                    ]
                    then_kw:<KW_Then then>
                    action:[
                      (command.Case
                        case_kw:<KW_Case case>
                        to_match:(case_arg.Word
                          w:(w
                            (DQ
                              (BracedVarSub
                                left:<Left_DollarBrace "${">
                                name_tok:<VSub_Name words>
                                var_name:words
                                bracket_op:(bracket_op.ArrayIndex
                                  expr:(arith_expr.Binary
                                    op:<Arith_Minus ->
                                    left:<Lit_ArithVarLike cword>
                                    right:(w <Lit_Digits 2>)
                                  )
                                )
                                right:<Right_DollarBrace "}">
                              )
                            )
                          )
                        )
                        arms_start:<KW_In in>
                        arms:[
                          (CaseArm
                            left:<Lit_Chars --set>
                            pattern:(pat.Words words:[(w <Lit_Chars --set>)])
                            middle:<Right_CasePat ")">
                            action:[
                              (command.ControlFlow
                                keyword:<ControlFlow_Return return>
                              )
                            ]
                            right:<Op_DSemi ";;">
                          )
                          (CaseArm
                            left:<Lit_Chars --addmode>
                            pattern:(pat.Words
                              words:[(w <Lit_Chars --addmode>)]
                            )
                            middle:<Right_CasePat ")">
                            action:[
                              (C
                                (w
                                  <
                                    Lit_Chars
                                    _comp_cmd_xrandr__compgen_all_modes
                                  >
                                )
                                (w (DQ ($ 1)))
                              )
                              (command.ControlFlow
                                keyword:<ControlFlow_Return return>
                              )
                            ]
                            right:<Op_DSemi ";;">
                          )
                          (CaseArm
                            left:<Lit_Chars --delmode>
                            pattern:(pat.Words
                              words:[(w <Lit_Chars --delmode>)]
                            )
                            middle:<Right_CasePat ")">
                            action:[
                              (C
                                (w <Lit_Chars _comp_cmd_xrandr__compgen_modes>)
                                (w (DQ ($ 1)))
                                (w
                                  (DQ
                                    (BracedVarSub
                                      left:<Left_DollarBrace "${">
                                      name_tok:<VSub_Name words>
                                      var_name:words
                                      bracket_op:(bracket_op.ArrayIndex
                                        expr:(arith_expr.Binary
                                          op:<Arith_Minus ->
                                          left:<Lit_ArithVarLike cword>
                                          right:(w <Lit_Digits 1>)
                                        )
                                      )
                                      right:<Right_DollarBrace "}">
                                    )
                                  )
                                )
                              )
                              (command.ControlFlow
                                keyword:<ControlFlow_Return return>
                              )
                            ]
                            right:<Op_DSemi ";;">
                          )
                          (CaseArm
                            left:<Lit_Chars --setmonitor>
                            pattern:(pat.Words
                              words:[(w <Lit_Chars --setmonitor>)]
                            )
                            middle:<Right_CasePat ")">
                            action:[
                              (C
                                (w <Lit_Chars _comp_compgen>)
                                (w <Lit_Chars -->)
                                (w <Lit_Chars -W>)
                                (w (SQ auto))
                              )
                              (command.ControlFlow
                                keyword:<ControlFlow_Return return>
                              )
                            ]
                            right:<Op_DSemi ";;">
                          )
                          (CaseArm
                            left:<Lit_Chars --setprovideroutputsource>
                            pattern:(pat.Words
                              words:[(w <Lit_Chars --setprovideroutputsource>)]
                            )
                            middle:<Right_CasePat ")">
                            action:[
                              (C
                                (w
                                  <
                                    Lit_Chars
                                    _comp_cmd_xrandr__compgen_providers
                                  >
                                )
                                (w (DQ ($ 1)))
                                (w (DQ <Lit_Chars "Source Output">))
                              )
                              (C
                                (w <Lit_Chars _comp_compgen>)
                                (w <Lit_Chars -a>)
                                (w <Lit_Chars -->)
                                (w <Lit_Chars -W>)
                                (w (DQ <Lit_Chars 0x0>))
                              )
                              (command.ControlFlow
                                keyword:<ControlFlow_Return return>
                              )
                            ]
                            right:<Op_DSemi ";;">
                          )
                          (CaseArm
                            left:<Lit_Chars --setprovideroffloadsink>
                            pattern:(pat.Words
                              words:[(w <Lit_Chars --setprovideroffloadsink>)]
                            )
                            middle:<Right_CasePat ")">
                            action:[
                              (C
                                (w
                                  <
                                    Lit_Chars
                                    _comp_cmd_xrandr__compgen_providers
                                  >
                                )
                                (w (DQ ($ 1)))
                                (w (DQ <Lit_Chars "Sink Offload">))
                              )
                              (C
                                (w <Lit_Chars _comp_compgen>)
                                (w <Lit_Chars -a>)
                                (w <Lit_Chars -->)
                                (w <Lit_Chars -W>)
                                (w (DQ <Lit_Chars 0x0>))
                              )
                              (command.ControlFlow
                                keyword:<ControlFlow_Return return>
                              )
                            ]
                            right:<Op_DSemi ";;">
                          )
                        ]
                        arms_end:<KW_Esac esac>
                      )
                    ]
                    then_tok:...0x348e
                  )
                ]
                else_action:[]
                fi_kw:<KW_Fi fi>
              )
              (command.If
                if_kw:<KW_If if>
                arms:[
                  (IfArm
                    keyword:...0x38a2
                    cond:[
                      (command.Sentence
                        child:(command.DParen
                          left:<Op_DLeftParen "((">
                          child:(arith_expr.Binary
                            op:<Arith_GreatEqual ">=">
                            left:<Lit_ArithVarLike cword>
                            right:(w <Lit_Digits 3>)
                          )
                          right:<Op_DRightParen ")">
                        )
                        terminator:<Op_Semi ";">
                      )
                    ]
                    then_kw:<KW_Then then>
                    action:[
                      (command.Case
                        case_kw:<KW_Case case>
                        to_match:(case_arg.Word
                          w:(w
                            (DQ
                              (BracedVarSub
                                left:<Left_DollarBrace "${">
                                name_tok:<VSub_Name words>
                                var_name:words
                                bracket_op:(bracket_op.ArrayIndex
                                  expr:(arith_expr.Binary
                                    op:<Arith_Minus ->
                                    left:<Lit_ArithVarLike cword>
                                    right:(w <Lit_Digits 3>)
                                  )
                                )
                                right:<Right_DollarBrace "}">
                              )
                            )
                          )
                        )
                        arms_start:<KW_In in>
                        arms:[
                          (CaseArm
                            left:<Lit_Chars --setmonitor>
                            pattern:(pat.Words
                              words:[(w <Lit_Chars --setmonitor>)]
                            )
                            middle:<Right_CasePat ")">
                            action:[
                              (C
                                (w <Lit_Chars _comp_compgen>)
                                (w <Lit_Chars -c>)
                                (w
                                  (DQ
                                    (BracedVarSub
                                      left:<Left_DollarBrace "${">
                                      name_tok:<VSub_Name cur>
                                      var_name:cur
                                      suffix_op:(suffix_op.Unary
                                        op:<VOp1_DPound "##">
                                        arg_word:(w
                                          <Lit_Other "*">
                                          <Lit_Chars ",">
                                        )
                                      )
                                      right:<Right_DollarBrace "}">
                                    )
                                  )
                                )
                                (w <Lit_Chars -i>)
                                (w <Lit_Chars xrandr>)
                                (w <Lit_Chars outputs>)
                                (w (DQ ($ 1)))
                              )
                              (C
                                (w <Lit_Chars _comp_compgen>)
                                (w <Lit_Chars -ac>)
                                (w
                                  (DQ
                                    (BracedVarSub
                                      left:<Left_DollarBrace "${">
                                      name_tok:<VSub_Name cur>
                                      var_name:cur
                                      suffix_op:(suffix_op.Unary
                                        op:<VOp1_DPound "##">
                                        arg_word:(w
                                          <Lit_Other "*">
                                          <Lit_Chars ",">
                                        )
                                      )
                                      right:<Right_DollarBrace "}">
                                    )
                                  )
                                )
                                (w <Lit_Chars -->)
                                (w <Lit_Chars -W>)
                                (w (DQ <Lit_Chars none>))
                              )
                              (C
                                (w <Lit_Chars _comp_delimited>)
                                (w <Lit_Comma ",">)
                                (w <Lit_Chars -W>)
                                (w (SQ "\"${COMPREPLY[@]}\""))
                              )
                              (command.ControlFlow
                                keyword:<ControlFlow_Return return>
                              )
                            ]
                            right:<Op_DSemi ";;">
                          )
                        ]
                        arms_end:<KW_Esac esac>
                      )
                    ]
                    then_tok:...0x3852
                  )
                ]
                else_action:[]
                fi_kw:<KW_Fi fi>
              )
              (C (w <Lit_Chars local>) (w <Lit_Chars options>))
              (command.If
                if_kw:<KW_If if>
                arms:[
                  (IfArm
                    keyword:...0x3f96
                    cond:[
                      (command.Sentence
                        child:(command.DBracket
                          left:<KW_DLeftBracket "[[">
                          expr:(bool_expr.WordTest w:(w ($ has_output)))
                          right:<Lit_DRightBracket "]]">
                        )
                        terminator:<Op_Semi ";">
                      )
                    ]
                    then_kw:<KW_Then then>
                    action:[
                      (C
                        (w <Lit_Chars _comp_compgen>)
                        (w <Lit_Chars -v>)
                        (w <Lit_Chars options>)
                        (w <Lit_Chars help>)
                        (w <Lit_Chars ->)
                      )
                    ]
                    then_tok:...0x3f4a
                  )
                ]
                else_kw:<KW_Else else>
                else_action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -v>)
                    (w <Lit_Chars options>)
                    (w <Lit_Chars help>)
                    (w <Lit_Chars ->)
                  )
                ]
                fi_kw:<KW_Fi fi>
              )
              (C
                (w <Lit_Chars _comp_compgen>)
                (w <Lit_Chars -->)
                (w <Lit_Chars -W>)
                (w (SQ "\"${options[@]}\""))
              )
            ]
            right:<Lit_RBrace "}">
          )
          code_str:"_comp_cmd_xrandr()\n{\n    local cur prev words cword comp_args\n    _comp_initialize -- \"$@\" || return\n\n    local i output has_output=\"\"\n    for ((i = cword - 1; i > 0; i--)); do\n        if [[ ${words[i]} == --output ]]; then\n            output=${words[i + 1]}\n            has_output=set\n            break\n        fi\n    done\n\n    case \"$prev\" in\n        -display | -d | -s | --size | -r | --rate | --refresh | --screen | \\\n            --fb | --fbmm | --pos | --set | --scale | --transform | --crtc | \\\n            --panning | --gamma | --newmode | --rmmode | --setmonitor)\n            return\n            ;;\n        --output | --addmode | --delmode | --dpi)\n            _comp_cmd_xrandr__compgen_outputs \"$1\"\n            return\n            ;;\n        --left-of | --right-of | --above | --below | --same-as)\n            if [[ $has_output ]]; then\n                _comp_cmd_xrandr__compgen_outputs \"$1\"\n            fi\n            return\n            ;;\n        --mode)\n            if [[ $has_output ]]; then\n                _comp_cmd_xrandr__compgen_modes \"$1\" \"$output\"\n            fi\n            return\n            ;;\n        -o | --orientation)\n            _comp_compgen -- -W 'normal inverted left right 0 1 2 3'\n            return\n            ;;\n        --reflect)\n            if [[ $has_output ]]; then\n                _comp_compgen -- -W 'normal x y xy'\n            fi\n            return\n            ;;\n        --rotate)\n            if [[ $has_output ]]; then\n                _comp_compgen -- -W 'normal inverted left right'\n            fi\n            return\n            ;;\n        --filter)\n            if [[ $has_output ]]; then\n                _comp_compgen -- -W 'bilinear nearest'\n            fi\n            return\n            ;;\n        --setprovideroutputsource)\n            _comp_cmd_xrandr__compgen_providers \"$1\" \"Sink Output\"\n            return\n            ;;\n        --setprovideroffloadsink)\n            _comp_cmd_xrandr__compgen_providers \"$1\" \"Source Offload\"\n            return\n            ;;\n        --delmonitor)\n            _comp_cmd_xrandr__compgen_monitors \"$1\"\n            return\n            ;;\n    esac\n\n    # second arguments\n    if ((cword >= 2)); then\n        case \"${words[cword - 2]}\" in\n            --set)\n                return\n                ;;\n            --addmode)\n                _comp_cmd_xrandr__compgen_all_modes \"$1\"\n                return\n                ;;\n            --delmode)\n                _comp_cmd_xrandr__compgen_modes \"$1\" \"${words[cword - 1]}\"\n                return\n                ;;\n            --setmonitor)\n                _comp_compgen -- -W 'auto'\n                return\n                ;;\n            --setprovideroutputsource)\n                _comp_cmd_xrandr__compgen_providers \"$1\" \"Source Output\"\n                _comp_compgen -a -- -W \"0x0\"\n                return\n                ;;\n            --setprovideroffloadsink)\n                _comp_cmd_xrandr__compgen_providers \"$1\" \"Sink Offload\"\n                _comp_compgen -a -- -W \"0x0\"\n                return\n                ;;\n        esac\n    fi\n\n    # third arguments\n    if ((cword >= 3)); then\n        case \"${words[cword - 3]}\" in\n            --setmonitor)\n                _comp_compgen -c \"${cur##*,}\" -i xrandr outputs \"$1\"\n                _comp_compgen -ac \"${cur##*,}\" -- -W \"none\"\n                _comp_delimited , -W '\"${COMPREPLY[@]}\"'\n                return\n                ;;\n        esac\n    fi\n\n    local options\n    if [[ $has_output ]]; then\n        _comp_compgen -v options help - <<<\"$(\n            \"$1\" --help 2>/dev/null |\n                command sed -e 's/ or /\\n  /g' -e 's/<[^>]*>]//g'\n        )\"\n    else\n        # if no output is specified, remove per-output options\n        _comp_compgen -v options help - <<<\"$(\n            \"$1\" --help 2>/dev/null |\n                command sed -e '/^  -/!d' -e 's/ or /\\n  /g' -e 's/<[^>]*>]//g'\n        )\"\n    fi\n\n    _comp_compgen -- -W '\"${options[@]}\"'\n}"
        )
        (C
          (w <Lit_Chars complete>)
          (w <Lit_Chars -F>)
          (w <Lit_Chars _comp_cmd_xrandr>)
          (w <Lit_Chars xrandr>)
        )
      ]
      ops:[<Op_DAmp "&&">]
    )
  ]
)
(command.AndOr
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_xrdb>
      name:_comp_cmd_xrdb
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars cur>)
            (w <Lit_Chars prev>)
            (w <Lit_Chars words>)
            (w <Lit_Chars cword>)
            (w <Lit_Chars comp_args>)
          )
          (command.AndOr
            children:[
              (C
                (w <Lit_Chars _comp_initialize>)
                (w <Lit_Chars -->)
                (w (DQ ($ VSub_At)))
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DPipe "||">]
          )
          (command.Case
            case_kw:<KW_Case case>
            to_match:(case_arg.Word w:(w ($ prev)))
            arms_start:<KW_In in>
            arms:[
              (CaseArm
                left:<Lit_Chars -backup>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars -backup>)
                    (w <Lit_Chars -display>)
                    (w <Lit_Chars -help>)
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars -cpp>
                pattern:(pat.Words
                  words:[(w <Lit_Chars -cpp>) (w <Lit_Chars -edit>)]
                )
                middle:<Right_CasePat ")">
                action:[
                  (C (w <Lit_Chars _comp_compgen_filedir>))
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
            ]
            arms_end:<KW_Esac esac>
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x19aa
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.Binary
                        op_id:BoolBinary_GlobDEqual
                        left:(w ($ cur))
                        right:(w <Lit_Chars -> <Lit_Other "*">)
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (C (w <Lit_Chars _comp_compgen_help>))
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                then_tok:...0x193e
              )
            ]
            else_action:[]
            fi_kw:<KW_Fi fi>
          )
          (C (w <Lit_Chars _comp_compgen_filedir>))
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_xrdb()\n{\n    local cur prev words cword comp_args\n    _comp_initialize -- \"$@\" || return\n\n    case $prev in\n        -backup | -display | -help)\n            return\n            ;;\n        -cpp | -edit)\n            _comp_compgen_filedir\n            return\n            ;;\n    esac\n\n    if [[ $cur == -* ]]; then\n        _comp_compgen_help\n        return\n    fi\n\n    _comp_compgen_filedir\n}"
    )
    (C
      (w <Lit_Chars complete>)
      (w <Lit_Chars -F>)
      (w <Lit_Chars _comp_cmd_xrdb>)
      (w <Lit_Chars xrdb>)
    )
  ]
  ops:[<Op_DAmp "&&">]
)
      [[ $cword -gt 2 && ${words[cword - 2]} == --?(string)param ]] && return
                                                  ^~
./xsltproc:37: Extended glob won't work without FNM_EXTMATCH support in libc
(command.AndOr
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_xvfb_run>
      name:_comp_cmd_xvfb_run
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars cur>)
            (w <Lit_Chars prev>)
            (w <Lit_Chars words>)
            (w <Lit_Chars cword>)
            (w <Lit_Chars was_split>)
            (w <Lit_Chars comp_args>)
          )
          (command.AndOr
            children:[
              (C
                (w <Lit_Chars _comp_initialize>)
                (w <Lit_Chars -s>)
                (w <Lit_Chars -->)
                (w (DQ ($ VSub_At)))
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DPipe "||">]
          )
          (C
            (w <Lit_Chars local>)
            (w <Lit_VarLike "noargopts="> (SQ "!(-*|*[npsef]*)"))
          )
          (C (w <Lit_Chars local>) (w <Lit_Chars i>))
          (command.ForExpr
            keyword:<KW_For for>
            init:(arith_expr.BinaryAssign
              op_id:Arith_Equal
              left:<Lit_ArithVarLike i>
              right:(w <Lit_Digits 1>)
            )
            cond:(arith_expr.Binary
              op:<Arith_LessEqual "<=">
              left:<Lit_ArithVarLike i>
              right:<Lit_ArithVarLike cword>
            )
            update:(arith_expr.UnaryAssign
              op_id:Node_PostDPlus
              child:<Lit_ArithVarLike i>
            )
            body:(command.DoGroup
              left:<KW_Do do>
              children:[
                (command.If
                  if_kw:<KW_If if>
                  arms:[
                    (IfArm
                      keyword:...0x19fa
                      cond:[
                        (command.Sentence
                          child:(command.DBracket
                            left:<KW_DLeftBracket "[[">
                            expr:(bool_expr.Binary
                              op_id:BoolBinary_GlobNEqual
                              left:(w
                                (BracedVarSub
                                  left:<Left_DollarBrace "${">
                                  name_tok:<VSub_Name words>
                                  var_name:words
                                  bracket_op:(bracket_op.ArrayIndex
                                    expr:<Lit_ArithVarLike i>
                                  )
                                  right:<Right_DollarBrace "}">
                                )
                              )
                              right:(w <Lit_Chars -> <Lit_Other "*">)
                            )
                            right:<Lit_DRightBracket "]]">
                          )
                          terminator:<Op_Semi ";">
                        )
                      ]
                      then_kw:<KW_Then then>
                      action:[
                        (C (w <Lit_Chars _comp_command_offset>) (w ($ i)))
                        (command.ControlFlow
                          keyword:<ControlFlow_Return return>
                        )
                      ]
                      then_tok:...0x1976
                    )
                  ]
                  else_action:[]
                  fi_kw:<KW_Fi fi>
                )
                (command.AndOr
                  children:[
                    (command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.Binary
                        op_id:BoolBinary_GlobDEqual
                        left:(w
                          (BracedVarSub
                            left:<Left_DollarBrace "${">
                            name_tok:<VSub_Name words>
                            var_name:words
                            bracket_op:(bracket_op.ArrayIndex
                              expr:<Lit_ArithVarLike i>
                            )
                            right:<Right_DollarBrace "}">
                          )
                        )
                        right:(w
                          <Lit_Chars ->
                          (${ VSub_Name noargopts)
                          <Lit_Other "[">
                          <Lit_Chars npsef>
                          <Lit_Other "]">
                        )
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    (command.DParen
                      left:<Op_DLeftParen "((">
                      child:(arith_expr.UnaryAssign
                        op_id:Node_PostDPlus
                        child:<Lit_ArithVarLike i>
                      )
                      right:<Op_DRightParen ")">
                    )
                  ]
                  ops:[<Op_DAmp "&&">]
                )
              ]
              right:<KW_Done done>
            )
          )
          (command.Case
            case_kw:<KW_Case case>
            to_match:(case_arg.Word w:(w ($ prev)))
            arms_start:<KW_In in>
            arms:[
              (CaseArm
                left:<Lit_Chars --help>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --help>)
                    (w <Lit_Chars --server-num>)
                    (w <Lit_Chars --xauth-protocol>)
                    (w <Lit_Chars --server-args>)
                    (w
                      <Lit_Chars ->
                      (${ VSub_Name noargopts)
                      <Lit_LBracket "[">
                      <Lit_Chars hnps>
                      <Lit_RBracket "]">
                    )
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --error-file>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --error-file>)
                    (w <Lit_Chars --auth-file>)
                    (w
                      <Lit_Chars ->
                      (${ VSub_Name noargopts)
                      <Lit_LBracket "[">
                      <Lit_Chars ef>
                      <Lit_RBracket "]">
                    )
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (C (w <Lit_Chars _comp_compgen_filedir>))
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
            ]
            arms_end:<KW_Esac esac>
          )
          (command.AndOr
            children:[
              (command.DBracket
                left:<KW_DLeftBracket "[[">
                expr:(bool_expr.WordTest w:(w ($ was_split)))
                right:<Lit_DRightBracket "]]">
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DAmp "&&">]
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x1fd6
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.Binary
                        op_id:BoolBinary_GlobDEqual
                        left:(w ($ cur))
                        right:(w <Lit_Chars -> <Lit_Other "*">)
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (C (w <Lit_Chars _comp_compgen_help>))
                  (command.AndOr
                    children:[
                      (command.DBracket
                        left:<KW_DLeftBracket "[[">
                        expr:(bool_expr.Binary
                          op_id:BoolBinary_GlobDEqual
                          left:(w
                            (BracedVarSub
                              left:<Left_DollarBrace "${">
                              name_tok:<VSub_Name COMPREPLY>
                              var_name:COMPREPLY
                              suffix_op:(suffix_op.Unary
                                op:<VTest_Hyphen ->
                                arg_word:(w)
                              )
                              right:<Right_DollarBrace "}">
                            )
                          )
                          right:(w <Lit_Other "*"> <BoolBinary_GlobEqual "=">)
                        )
                        right:<Lit_DRightBracket "]]">
                      )
                      (C
                        (w <Lit_Chars compopt>)
                        (w <Lit_Chars -o>)
                        (w <Lit_Chars nospace>)
                      )
                    ]
                    ops:[<Op_DAmp "&&">]
                  )
                ]
                then_tok:...0x1f6a
              )
            ]
            else_action:[]
            fi_kw:<KW_Fi fi>
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_xvfb_run()\n{\n    local cur prev words cword was_split comp_args\n    _comp_initialize -s -- \"$@\" || return\n\n    local noargopts='!(-*|*[npsef]*)'\n    local i\n    for ((i = 1; i <= cword; i++)); do\n        if [[ ${words[i]} != -* ]]; then\n            _comp_command_offset $i\n            return\n        fi\n        # shellcheck disable=SC2254\n        [[ ${words[i]} == -${noargopts}[npsef] ]] && ((i++))\n    done\n\n    # shellcheck disable=SC2254\n    case $prev in\n        --help | --server-num | --xauth-protocol | --server-args | -${noargopts}[hnps])\n            return\n            ;;\n        --error-file | --auth-file | -${noargopts}[ef])\n            _comp_compgen_filedir\n            return\n            ;;\n    esac\n\n    [[ $was_split ]] && return\n\n    if [[ $cur == -* ]]; then\n        _comp_compgen_help\n        [[ ${COMPREPLY-} == *= ]] && compopt -o nospace\n    fi\n}"
    )
    (C
      (w <Lit_Chars complete>)
      (w <Lit_Chars -F>)
      (w <Lit_Chars _comp_cmd_xvfb_run>)
      (w <Lit_Chars xvfb-run>)
    )
  ]
  ops:[<Op_DAmp "&&">]
)
(command.AndOr
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_xxd>
      name:_comp_cmd_xxd
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars cur>)
            (w <Lit_Chars prev>)
            (w <Lit_Chars words>)
            (w <Lit_Chars cword>)
            (w <Lit_Chars comp_args>)
          )
          (command.AndOr
            children:[
              (C
                (w <Lit_Chars _comp_initialize>)
                (w <Lit_Chars -->)
                (w (DQ ($ VSub_At)))
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DPipe "||">]
          )
          (command.Case
            case_kw:<KW_Case case>
            to_match:(case_arg.Word w:(w ($ prev)))
            arms_start:<KW_In in>
            arms:[
              (CaseArm
                left:<Lit_Chars -h>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars -h>)
                    (w <Lit_Chars -help>)
                    (w <Lit_Chars -c>)
                    (w <Lit_Chars -cols>)
                    (w <Lit_Chars -g>)
                    (w <Lit_Chars -groupsize>)
                    (w <Lit_Chars -l>)
                    (w <Lit_Chars -len>)
                    (w <Lit_Chars -n>)
                    (w <Lit_Chars -name>)
                    (w <Lit_Chars -o>)
                    (w <Lit_Chars -s>)
                    (w <Lit_Chars -seek>)
                    (w <Lit_Chars -v>)
                    (w <Lit_Chars -version>)
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars -R>
                pattern:(pat.Words words:[(w <Lit_Chars -R>)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (DQ <Lit_Chars "always auto never">))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
            ]
            arms_end:<KW_Esac esac>
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x188a
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.Binary
                        op_id:BoolBinary_GlobDEqual
                        left:(w ($ cur))
                        right:(w <Lit_Chars -> <Lit_Other "*">)
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen_help>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -h>)
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                then_tok:...0x181e
              )
            ]
            else_action:[]
            fi_kw:<KW_Fi fi>
          )
          (C (w <Lit_Chars _comp_compgen_filedir>))
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_xxd()\n{\n    local cur prev words cword comp_args\n    _comp_initialize -- \"$@\" || return\n\n    case $prev in\n        -h | -help | -c | -cols | -g | -groupsize | -l | -len | -n | -name | \\\n            -o | -s | -seek | -v | -version)\n            return\n            ;;\n        -R)\n            _comp_compgen -- -W \"always auto never\"\n            return\n            ;;\n    esac\n\n    if [[ $cur == -* ]]; then\n        _comp_compgen_help -- -h\n        return\n    fi\n\n    _comp_compgen_filedir\n}"
    )
    (C
      (w <Lit_Chars complete>)
      (w <Lit_Chars -F>)
      (w <Lit_Chars _comp_cmd_xxd>)
      (w <Lit_Chars xxd>)
    )
  ]
  ops:[<Op_DAmp "&&">]
)
(command.AndOr
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_xz>
      name:_comp_cmd_xz
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars cur>)
            (w <Lit_Chars prev>)
            (w <Lit_Chars words>)
            (w <Lit_Chars cword>)
            (w <Lit_Chars was_split>)
            (w <Lit_Chars comp_args>)
          )
          (command.AndOr
            children:[
              (C
                (w <Lit_Chars _comp_initialize>)
                (w <Lit_Chars -s>)
                (w <Lit_Chars -->)
                (w (DQ ($ VSub_At)))
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DPipe "||">]
          )
          (C
            (w <Lit_Chars local>)
            (w <Lit_VarLike "xspec="> (DQ <Lit_Chars "*.@(xz|lzma|txz|tlz)">))
          )
          (C
            (w <Lit_Chars local>)
            (w <Lit_VarLike "noargopts="> (SQ "!(-*|*[CFTMS]*)"))
          )
          (command.Case
            case_kw:<KW_Case case>
            to_match:(case_arg.Word w:(w ($ prev)))
            arms_start:<KW_In in>
            arms:[
              (CaseArm
                left:<Lit_Chars --decompress>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --decompress>)
                    (w <Lit_Chars --list>)
                    (w <Lit_Chars --test>)
                    (w
                      <Lit_Chars ->
                      (${ VSub_Name noargopts)
                      <Lit_LBracket "[">
                      <Lit_Chars dlt>
                      <Lit_RBracket "]">
                      <Lit_Star "*">
                    )
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (command.ShAssignment
                    left:<Lit_VarLike "xspec=">
                    pairs:[
                      (AssignPair
                        left:...0x19be
                        lhs:(sh_lhs.Name left:...0x19be name:xspec)
                        op:assign_op.Equal
                        rhs:(w (DQ <Lit_Chars "!">) ($ xspec))
                      )
                    ]
                  )
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --files>
                pattern:(pat.Words
                  words:[(w <Lit_Chars --files>) (w <Lit_Chars --files0>)]
                )
                middle:<Right_CasePat ")">
                action:[
                  (C (w <Lit_Chars _comp_compgen_filedir>))
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --check>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --check>)
                    (w <Lit_Chars -> (${ VSub_Name noargopts) <Lit_Chars C>)
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ "crc32 crc64 sha256 none"))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --format>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --format>)
                    (w <Lit_Chars -> (${ VSub_Name noargopts) <Lit_Chars F>)
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ "auto xz lzma raw"))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --threads>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --threads>)
                    (w <Lit_Chars -> (${ VSub_Name noargopts) <Lit_Chars T>)
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (C (w <Lit_Chars local>) (w <Lit_Chars REPLY>))
                  (C (w <Lit_Chars _comp_get_ncpus>))
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (DQ <Lit_Chars "{0.."> ($ REPLY) <Lit_Chars "}">))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --memlimit>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --memlimit>)
                    (w <Lit_Chars --memlimit-compress>)
                    (w <Lit_Chars --memlimit-decompress>)
                    (w <Lit_Chars --memory>)
                    (w <Lit_Chars --suffix>)
                    (w <Lit_Chars --delta>)
                    (w <Lit_Chars --lzma1>)
                    (w <Lit_Chars --lzma2>)
                    (w
                      <Lit_Chars ->
                      (${ VSub_Name noargopts)
                      <Lit_LBracket "[">
                      <Lit_Chars MS>
                      <Lit_RBracket "]">
                    )
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --help>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --help>)
                    (w <Lit_Chars --long-help>)
                    (w <Lit_Chars --version>)
                    (w <Lit_Chars --info-memory>)
                    (w
                      <Lit_Chars ->
                      (${ VSub_Name noargopts)
                      <Lit_LBracket "[">
                      <Lit_Chars hHV>
                      <Lit_RBracket "]">
                    )
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
            ]
            arms_end:<KW_Esac esac>
          )
          (command.AndOr
            children:[
              (command.DBracket
                left:<KW_DLeftBracket "[[">
                expr:(bool_expr.WordTest w:(w ($ was_split)))
                right:<Lit_DRightBracket "]]">
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DAmp "&&">]
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x1d1e
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.Binary
                        op_id:BoolBinary_GlobDEqual
                        left:(w ($ cur))
                        right:(w <Lit_Chars -> <Lit_Other "*">)
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen_help>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars --long-help>)
                  )
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -a>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ "{-1..-9}"))
                  )
                  (command.AndOr
                    children:[
                      (command.DBracket
                        left:<KW_DLeftBracket "[[">
                        expr:(bool_expr.Binary
                          op_id:BoolBinary_GlobDEqual
                          left:(w
                            (BracedVarSub
                              left:<Left_DollarBrace "${">
                              name_tok:<VSub_Name COMPREPLY>
                              var_name:COMPREPLY
                              suffix_op:(suffix_op.Unary
                                op:<VTest_Hyphen ->
                                arg_word:(w)
                              )
                              right:<Right_DollarBrace "}">
                            )
                          )
                          right:(w <Lit_Other "*"> <BoolBinary_GlobEqual "=">)
                        )
                        right:<Lit_DRightBracket "]]">
                      )
                      (C
                        (w <Lit_Chars compopt>)
                        (w <Lit_Chars -o>)
                        (w <Lit_Chars nospace>)
                      )
                    ]
                    ops:[<Op_DAmp "&&">]
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                then_tok:...0x1cb2
              )
            ]
            else_action:[]
            fi_kw:<KW_Fi fi>
          )
          (command.AndOr
            children:[
              (C (w <Lit_Chars _comp_compgen_tilde>))
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DAmp "&&">]
          )
          (C
            (w <Lit_Chars compopt>)
            (w <Lit_Chars -o>)
            (w <Lit_Chars filenames>)
          )
          (C
            (w <Lit_Chars _comp_compgen>)
            (w <Lit_Chars -->)
            (w <Lit_Chars -f>)
            (w <Lit_Chars -X>)
            (w (DQ ($ xspec)))
            (w <Lit_Chars -o>)
            (w <Lit_Chars plusdirs>)
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_xz()\n{\n    local cur prev words cword was_split comp_args\n    _comp_initialize -s -- \"$@\" || return\n\n    local xspec=\"*.@(xz|lzma|txz|tlz)\"\n\n    local noargopts='!(-*|*[CFTMS]*)'\n    # shellcheck disable=SC2254\n    case $prev in\n        --decompress | --list | --test | -${noargopts}[dlt]*)\n            xspec=\"!\"$xspec\n            ;;\n        --files | --files0)\n            _comp_compgen_filedir\n            return\n            ;;\n        --check | -${noargopts}C)\n            _comp_compgen -- -W 'crc32 crc64 sha256 none'\n            return\n            ;;\n        --format | -${noargopts}F)\n            _comp_compgen -- -W 'auto xz lzma raw'\n            return\n            ;;\n        --threads | -${noargopts}T)\n            local REPLY\n            _comp_get_ncpus\n            _comp_compgen -- -W \"{0..$REPLY}\"\n            return\n            ;;\n        --memlimit | --memlimit-compress | --memlimit-decompress | --memory | \\\n            --suffix | --delta | --lzma1 | --lzma2 | -${noargopts}[MS])\n            return\n            ;;\n        --help | --long-help | --version | --info-memory | -${noargopts}[hHV])\n            return\n            ;;\n    esac\n\n    [[ $was_split ]] && return\n\n    if [[ $cur == -* ]]; then\n        _comp_compgen_help -- --long-help\n        _comp_compgen -a -- -W '{-1..-9}'\n        [[ ${COMPREPLY-} == *= ]] && compopt -o nospace\n        return\n    fi\n\n    _comp_compgen_tilde && return\n\n    compopt -o filenames\n    _comp_compgen -- -f -X \"$xspec\" -o plusdirs\n}"
    )
    (C
      (w <Lit_Chars complete>)
      (w <Lit_Chars -F>)
      (w <Lit_Chars _comp_cmd_xz>)
      (w <Lit_Chars xz>)
      (w <Lit_Chars pxz>)
    )
  ]
  ops:[<Op_DAmp "&&">]
)
(command.AndOr
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_xzdec>
      name:_comp_cmd_xzdec
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars cur>)
            (w <Lit_Chars prev>)
            (w <Lit_Chars words>)
            (w <Lit_Chars cword>)
            (w <Lit_Chars was_split>)
            (w <Lit_Chars comp_args>)
          )
          (command.AndOr
            children:[
              (C
                (w <Lit_Chars _comp_initialize>)
                (w <Lit_Chars -s>)
                (w <Lit_Chars -->)
                (w (DQ ($ VSub_At)))
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DPipe "||">]
          )
          (C
            (w <Lit_Chars local>)
            (w <Lit_VarLike "noargopts="> (SQ "!(-*|*M*)"))
          )
          (command.Case
            case_kw:<KW_Case case>
            to_match:(case_arg.Word w:(w ($ prev)))
            arms_start:<KW_In in>
            arms:[
              (CaseArm
                left:<Lit_Chars --memory>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --memory>)
                    (w <Lit_Chars -> (${ VSub_Name noargopts) <Lit_Chars M>)
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --help>
                pattern:(pat.Words
                  words:[
                    (w <Lit_Chars --help>)
                    (w <Lit_Chars --version>)
                    (w
                      <Lit_Chars ->
                      (${ VSub_Name noargopts)
                      <Lit_LBracket "[">
                      <Lit_Chars hV>
                      <Lit_RBracket "]">
                    )
                  ]
                )
                middle:<Right_CasePat ")">
                action:[
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
            ]
            arms_end:<KW_Esac esac>
          )
          (command.AndOr
            children:[
              (command.DBracket
                left:<KW_DLeftBracket "[[">
                expr:(bool_expr.WordTest w:(w ($ was_split)))
                right:<Lit_DRightBracket "]]">
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DAmp "&&">]
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x18ba
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.Binary
                        op_id:BoolBinary_GlobDEqual
                        left:(w ($ cur))
                        right:(w <Lit_Chars -> <Lit_Other "*">)
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (C (w <Lit_Chars _comp_compgen_help>))
                  (command.AndOr
                    children:[
                      (command.DBracket
                        left:<KW_DLeftBracket "[[">
                        expr:(bool_expr.Binary
                          op_id:BoolBinary_GlobDEqual
                          left:(w
                            (BracedVarSub
                              left:<Left_DollarBrace "${">
                              name_tok:<VSub_Name COMPREPLY>
                              var_name:COMPREPLY
                              suffix_op:(suffix_op.Unary
                                op:<VTest_Hyphen ->
                                arg_word:(w)
                              )
                              right:<Right_DollarBrace "}">
                            )
                          )
                          right:(w <Lit_Other "*"> <BoolBinary_GlobEqual "=">)
                        )
                        right:<Lit_DRightBracket "]]">
                      )
                      (C
                        (w <Lit_Chars compopt>)
                        (w <Lit_Chars -o>)
                        (w <Lit_Chars nospace>)
                      )
                    ]
                    ops:[<Op_DAmp "&&">]
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                then_tok:...0x184e
              )
            ]
            else_action:[]
            fi_kw:<KW_Fi fi>
          )
          (C (w <Lit_Chars _comp_compgen_filedir>) (w <Lit_Chars xz>))
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_xzdec()\n{\n    local cur prev words cword was_split comp_args\n    _comp_initialize -s -- \"$@\" || return\n\n    local noargopts='!(-*|*M*)'\n    # shellcheck disable=SC2254\n    case $prev in\n        --memory | -${noargopts}M)\n            return\n            ;;\n        --help | --version | -${noargopts}[hV])\n            return\n            ;;\n    esac\n\n    [[ $was_split ]] && return\n\n    if [[ $cur == -* ]]; then\n        _comp_compgen_help\n        [[ ${COMPREPLY-} == *= ]] && compopt -o nospace\n        return\n    fi\n\n    _comp_compgen_filedir xz # no lzma support here as of xz 4.999.9beta\n}"
    )
    (C
      (w <Lit_Chars complete>)
      (w <Lit_Chars -F>)
      (w <Lit_Chars _comp_cmd_xzdec>)
      (w <Lit_Chars xzdec>)
    )
  ]
  ops:[<Op_DAmp "&&">]
)
(command.AndOr
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_ypmatch>
      name:_comp_cmd_ypmatch
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars cur>)
            (w <Lit_Chars prev>)
            (w <Lit_Chars words>)
            (w <Lit_Chars cword>)
            (w <Lit_Chars comp_args>)
          )
          (command.AndOr
            children:[
              (C
                (w <Lit_Chars _comp_initialize>)
                (w <Lit_Chars -->)
                (w (DQ ($ VSub_At)))
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DPipe "||">]
          )
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars map>)
            (w
              <Lit_VarLike "cmd=">
              (BracedVarSub
                left:<Left_DollarBrace "${">
                name_tok:<VSub_Number 1>
                var_name:1
                suffix_op:(suffix_op.Unary
                  op:<VOp1_DPound "##">
                  arg_word:(w <Lit_Other "*"> <Lit_Slash />)
                )
                right:<Right_DollarBrace "}">
              )
            )
          )
          (command.AndOr
            children:[
              (command.DBracket
                left:<KW_DLeftBracket "[[">
                expr:(bool_expr.LogicalAnd
                  left:(bool_expr.Binary
                    op_id:BoolBinary_GlobDEqual
                    left:(w ($ cmd))
                    right:(w <Lit_Chars ypcat>)
                  )
                  right:(bool_expr.Binary
                    op_id:BoolBinary_gt
                    left:(w ($ cword))
                    right:(w <Lit_Chars 1>)
                  )
                )
                right:<Lit_DRightBracket "]]">
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DAmp "&&">]
          )
          (command.AndOr
            children:[
              (command.DBracket
                left:<KW_DLeftBracket "[[">
                expr:(bool_expr.LogicalAnd
                  left:(bool_expr.Binary
                    op_id:BoolBinary_GlobDEqual
                    left:(w ($ cmd))
                    right:(w <Lit_Chars ypmatch>)
                  )
                  right:(bool_expr.Binary
                    op_id:BoolBinary_gt
                    left:(w ($ cword))
                    right:(w <Lit_Chars 2>)
                  )
                )
                right:<Lit_DRightBracket "]]">
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DAmp "&&">]
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x1966
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.LogicalAnd
                        left:(bool_expr.Binary
                          op_id:BoolBinary_GlobDEqual
                          left:(w ($ cmd))
                          right:(w <Lit_Chars ypmatch>)
                        )
                        right:(bool_expr.LogicalAnd
                          left:(bool_expr.Binary
                            op_id:BoolBinary_eq
                            left:(w ($ cword))
                            right:(w <Lit_Chars 1>)
                          )
                          right:(bool_expr.Binary
                            op_id:BoolBinary_eq
                            left:(w
                              (BracedVarSub
                                left:<Left_DollarBrace "${">
                                name_tok:<VSub_Name words>
                                var_name:words
                                prefix_op:<VSub_Pound "#">
                                bracket_op:(bracket_op.WholeArray op_id:Lit_At)
                                right:<Right_DollarBrace "}">
                              )
                            )
                            right:(w <Lit_Chars 3>)
                          )
                        )
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (command.ShAssignment
                    left:<Lit_VarLike "map=">
                    pairs:[
                      (AssignPair
                        left:...0x1866
                        lhs:(sh_lhs.Name left:...0x1866 name:map)
                        op:assign_op.Equal
                        rhs:(w
                          (BracedVarSub
                            left:<Left_DollarBrace "${">
                            name_tok:<VSub_Name words>
                            var_name:words
                            bracket_op:(bracket_op.ArrayIndex
                              expr:(w <Lit_Digits 2>)
                            )
                            right:<Right_DollarBrace "}">
                          )
                        )
                      )
                    ]
                  )
                  (C
                    (w <Lit_Chars _comp_compgen_split>)
                    (w <Lit_Chars -->)
                    (w
                      (DQ
                        (CommandSub
                          left_token:<Left_DollarParen "$(">
                          child:(command.Pipeline
                            children:[
                              (C (w <Lit_Chars ypcat>) (w (DQ ($ map))))
                              (C
                                (w <Lit_Chars cut>)
                                (w <Lit_Chars -d> (SQ ":"))
                                (w <Lit_Chars -f>)
                                (w <Lit_Number 1>)
                              )
                            ]
                            ops:[<Op_Pipe "|">]
                          )
                          right:<Eof_RParen ")">
                        )
                      )
                    )
                  )
                ]
                then_tok:...0x1886
              )
            ]
            else_kw:<KW_Else else>
            else_action:[
              (command.AndOr
                children:[
                  (command.DBracket
                    left:<KW_DLeftBracket "[[">
                    expr:(bool_expr.LogicalAnd
                      left:(bool_expr.Binary
                        op_id:BoolBinary_GlobDEqual
                        left:(w ($ cmd))
                        right:(w <Lit_Chars ypmatch>)
                      )
                      right:(bool_expr.Binary
                        op_id:BoolBinary_ne
                        left:(w ($ cword))
                        right:(w <Lit_Chars 2>)
                      )
                    )
                    right:<Lit_DRightBracket "]]">
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                ops:[<Op_DAmp "&&">]
              )
              (C
                (w <Lit_Chars _comp_compgen_split>)
                (w <Lit_Chars -->)
                (w
                  (DQ
                    (CommandSub
                      left_token:<Left_DollarParen "$(">
                      child:(command.Pipeline
                        children:[
                          (C (w <Lit_Chars ypcat>) (w <Lit_Chars -x>))
                          (C
                            (w <Lit_Chars cut>)
                            (w <Lit_Chars -d> (SQ "\""))
                            (w <Lit_Chars -f>)
                            (w <Lit_Number 2>)
                          )
                        ]
                        ops:[<Op_Pipe "|">]
                      )
                      right:<Eof_RParen ")">
                    )
                  )
                )
              )
            ]
            fi_kw:<KW_Fi fi>
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_ypmatch()\n{\n    local cur prev words cword comp_args\n    _comp_initialize -- \"$@\" || return\n\n    local map cmd=${1##*/}\n\n    [[ $cmd == ypcat && $cword -gt 1 ]] && return\n    [[ $cmd == ypmatch && $cword -gt 2 ]] && return\n\n    if [[ $cmd == ypmatch && $cword -eq 1 && ${#words[@]} -eq 3 ]]; then\n        map=${words[2]}\n        _comp_compgen_split -- \"$(ypcat \"$map\" 2>/dev/null | cut -d':' -f 1)\"\n    else\n        [[ $cmd == ypmatch && $cword -ne 2 ]] && return\n        _comp_compgen_split -- \"$(ypcat -x 2>/dev/null | cut -d'\"' -f 2)\"\n    fi\n}"
    )
    (C
      (w <Lit_Chars complete>)
      (w <Lit_Chars -F>)
      (w <Lit_Chars _comp_cmd_ypmatch>)
      (w <Lit_Chars ypmatch>)
      (w <Lit_Chars ypcat>)
    )
  ]
  ops:[<Op_DAmp "&&">]
)
(C
  (w <Lit_Chars eval>)
  (w <Lit_Chars -->)
  (w
    (DQ
      (CommandSub
        left_token:<Left_DollarParen "$(">
        child:(C
          (w (DQ ($ 1)))
          (w <Lit_Chars shell-completion>)
          (w <Lit_Chars bash>)
        )
        right:<Eof_RParen ")">
      )
    )
  )
)
          if [[ ${words[i]} == @(install|update|upgrade|remove|erase|deplist|info) ]]; then
                               ^~
./_yum:50: Extended glob won't work without FNM_EXTMATCH support in libc
(command.AndOr
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_yum_arch>
      name:_comp_cmd_yum_arch
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars cur>)
            (w <Lit_Chars prev>)
            (w <Lit_Chars words>)
            (w <Lit_Chars cword>)
            (w <Lit_Chars comp_args>)
          )
          (command.AndOr
            children:[
              (C
                (w <Lit_Chars _comp_initialize>)
                (w <Lit_Chars -->)
                (w (DQ ($ VSub_At)))
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DPipe "||">]
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x109a
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.Binary
                        op_id:BoolBinary_GlobDEqual
                        left:(w ($ cur))
                        right:(w <Lit_Chars -> <Lit_Other "*">)
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ "-d -v -vv -n -c -z -s -l -q"))
                  )
                ]
                then_tok:...0x102e
              )
            ]
            else_kw:<KW_Else else>
            else_action:[
              (C (w <Lit_Chars _comp_compgen_filedir>) (w <Lit_Chars -d>))
            ]
            fi_kw:<KW_Fi fi>
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_yum_arch()\n{\n    local cur prev words cword comp_args\n    _comp_initialize -- \"$@\" || return\n\n    if [[ $cur == -* ]]; then\n        _comp_compgen -- -W '-d -v -vv -n -c -z -s -l -q'\n    else\n        _comp_compgen_filedir -d\n    fi\n}"
    )
    (C
      (w <Lit_Chars complete>)
      (w <Lit_Chars -F>)
      (w <Lit_Chars _comp_cmd_yum_arch>)
      (w <Lit_Chars yum-arch>)
    )
  ]
  ops:[<Op_DAmp "&&">]
)
(command.AndOr
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_zopfli>
      name:_comp_cmd_zopfli
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars cur>)
            (w <Lit_Chars prev>)
            (w <Lit_Chars words>)
            (w <Lit_Chars cword>)
            (w <Lit_Chars comp_args>)
          )
          (command.AndOr
            children:[
              (C
                (w <Lit_Chars _comp_initialize>)
                (w <Lit_Chars -->)
                (w (DQ ($ VSub_At)))
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DPipe "||">]
          )
          (command.Case
            case_kw:<KW_Case case>
            to_match:(case_arg.Word w:(w ($ prev)))
            arms_start:<KW_In in>
            arms:[
              (CaseArm
                left:<Lit_Chars -h>
                pattern:(pat.Words words:[(w <Lit_Chars -h>)])
                middle:<Right_CasePat ")">
                action:[
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
            ]
            arms_end:<KW_Esac esac>
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x1a7a
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.Binary
                        op_id:BoolBinary_GlobDEqual
                        left:(w ($ cur))
                        right:(w <Lit_Chars -> <Lit_Other "*">)
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -R>)
                    (w <Lit_Chars help>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -h>)
                  )
                  (command.AndOr
                    children:[
                      (command.DParen
                        left:<Op_DLeftParen "((">
                        child:(w
                          (BracedVarSub
                            left:<Left_DollarBrace "${">
                            name_tok:<VSub_Name COMPREPLY>
                            var_name:COMPREPLY
                            prefix_op:<VSub_Pound "#">
                            bracket_op:(bracket_op.WholeArray op_id:Lit_At)
                            right:<Right_DollarBrace "}">
                          )
                        )
                        right:<Op_DRightParen ")">
                      )
                      (C
                        (w <Lit_Chars _comp_compgen>)
                        (w <Lit_Chars -->)
                        (w <Lit_Chars -W>)
                        (w (SQ "\"${COMPREPLY[@]%#}\""))
                      )
                    ]
                    ops:[<Op_DAmp "&&">]
                  )
                  (command.AndOr
                    children:[
                      (command.DBracket
                        left:<KW_DLeftBracket "[[">
                        expr:(bool_expr.Binary
                          op_id:BoolBinary_GlobDEqual
                          left:(w
                            (BracedVarSub
                              left:<Left_DollarBrace "${">
                              name_tok:<VSub_Name COMPREPLY>
                              var_name:COMPREPLY
                              suffix_op:(suffix_op.Unary
                                op:<VTest_Hyphen ->
                                arg_word:(w)
                              )
                              right:<Right_DollarBrace "}">
                            )
                          )
                          right:(w <Lit_Chars --i>)
                        )
                        right:<Lit_DRightBracket "]]">
                      )
                      (C
                        (w <Lit_Chars compopt>)
                        (w <Lit_Chars -o>)
                        (w <Lit_Chars nospace>)
                      )
                    ]
                    ops:[<Op_DAmp "&&">]
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                then_tok:...0x1a0e
              )
            ]
            else_action:[]
            fi_kw:<KW_Fi fi>
          )
          (command.AndOr
            children:[
              (C (w <Lit_Chars _comp_compgen_tilde>))
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DAmp "&&">]
          )
          (C
            (w <Lit_Chars local>)
            (w <Lit_VarLike "xspec="> (DQ <Lit_Chars "*.@(gz|t[ag]z)">))
          )
          (C
            (w <Lit_Chars compopt>)
            (w <Lit_Chars -o>)
            (w <Lit_Chars filenames>)
          )
          (C
            (w <Lit_Chars _comp_compgen>)
            (w <Lit_Chars -->)
            (w <Lit_Chars -f>)
            (w <Lit_Chars -X>)
            (w (DQ ($ xspec)))
            (w <Lit_Chars -o>)
            (w <Lit_Chars plusdirs>)
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_zopfli()\n{\n    local cur prev words cword comp_args\n    _comp_initialize -- \"$@\" || return\n\n    case $prev in\n        -h)\n            return\n            ;;\n    esac\n\n    if [[ $cur == -* ]]; then\n        _comp_compgen -R help -- -h\n        ((${#COMPREPLY[@]})) &&\n            _comp_compgen -- -W '\"${COMPREPLY[@]%#}\"'\n        [[ ${COMPREPLY-} == --i ]] && compopt -o nospace\n        return\n    fi\n\n    _comp_compgen_tilde && return\n\n    local xspec=\"*.@(gz|t[ag]z)\"\n    compopt -o filenames\n    _comp_compgen -- -f -X \"$xspec\" -o plusdirs\n}"
    )
    (C
      (w <Lit_Chars complete>)
      (w <Lit_Chars -F>)
      (w <Lit_Chars _comp_cmd_zopfli>)
      (w <Lit_Chars zopfli>)
    )
  ]
  ops:[<Op_DAmp "&&">]
)
(command.AndOr
  children:[
    (ShFunction
      name_tok:<Lit_Chars _comp_cmd_zopflipng>
      name:_comp_cmd_zopflipng
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C
            (w <Lit_Chars local>)
            (w <Lit_Chars cur>)
            (w <Lit_Chars prev>)
            (w <Lit_Chars words>)
            (w <Lit_Chars cword>)
            (w <Lit_Chars was_split>)
            (w <Lit_Chars comp_args>)
          )
          (command.AndOr
            children:[
              (C
                (w <Lit_Chars _comp_initialize>)
                (w <Lit_Chars -s>)
                (w <Lit_Chars -->)
                (w (DQ ($ VSub_At)))
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DPipe "||">]
          )
          (command.Case
            case_kw:<KW_Case case>
            to_match:(case_arg.Word w:(w ($ prev)))
            arms_start:<KW_In in>
            arms:[
              (CaseArm
                left:<Lit_Chars -h>
                pattern:(pat.Words
                  words:[(w <Lit_Chars -h>) (w <Lit_Chars --help>)]
                )
                middle:<Right_CasePat ")">
                action:[
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
              (CaseArm
                left:<Lit_Chars --splitting>
                pattern:(pat.Words words:[(w <Lit_Chars --splitting>)])
                middle:<Right_CasePat ")">
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -W>)
                    (w (SQ "{0..3}"))
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                right:<Op_DSemi ";;">
              )
            ]
            arms_end:<KW_Esac esac>
          )
          (command.AndOr
            children:[
              (command.DBracket
                left:<KW_DLeftBracket "[[">
                expr:(bool_expr.WordTest w:(w ($ was_split)))
                right:<Lit_DRightBracket "]]">
              )
              (command.ControlFlow keyword:<ControlFlow_Return return>)
            ]
            ops:[<Op_DAmp "&&">]
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x18fe
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.Binary
                        op_id:BoolBinary_GlobDEqual
                        left:(w ($ cur))
                        right:(w <Lit_Chars -> <Lit_Other "*">)
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (C
                    (w <Lit_Chars _comp_compgen>)
                    (w <Lit_Chars -R>)
                    (w <Lit_Chars help>)
                    (w <Lit_Chars -->)
                    (w <Lit_Chars -h>)
                  )
                  (command.AndOr
                    children:[
                      (command.DParen
                        left:<Op_DLeftParen "((">
                        child:(w
                          (BracedVarSub
                            left:<Left_DollarBrace "${">
                            name_tok:<VSub_Name COMPREPLY>
                            var_name:COMPREPLY
                            prefix_op:<VSub_Pound "#">
                            bracket_op:(bracket_op.WholeArray op_id:Lit_At)
                            right:<Right_DollarBrace "}">
                          )
                        )
                        right:<Op_DRightParen ")">
                      )
                      (C
                        (w <Lit_Chars _comp_compgen>)
                        (w <Lit_Chars -->)
                        (w <Lit_Chars -W>)
                        (w (SQ "\"${COMPREPLY[@]%:}\""))
                      )
                    ]
                    ops:[<Op_DAmp "&&">]
                  )
                  (command.AndOr
                    children:[
                      (command.DBracket
                        left:<KW_DLeftBracket "[[">
                        expr:(bool_expr.Binary
                          op_id:BoolBinary_GlobDEqual
                          left:(w
                            (BracedVarSub
                              left:<Left_DollarBrace "${">
                              name_tok:<VSub_Name COMPREPLY>
                              var_name:COMPREPLY
                              suffix_op:(suffix_op.Unary
                                op:<VTest_Hyphen ->
                                arg_word:(w)
                              )
                              right:<Right_DollarBrace "}">
                            )
                          )
                          right:(w <Lit_Other "*"> <BoolBinary_GlobEqual "=">)
                        )
                        right:<Lit_DRightBracket "]]">
                      )
                      (C
                        (w <Lit_Chars compopt>)
                        (w <Lit_Chars -o>)
                        (w <Lit_Chars nospace>)
                      )
                    ]
                    ops:[<Op_DAmp "&&">]
                  )
                  (command.ControlFlow keyword:<ControlFlow_Return return>)
                ]
                then_tok:...0x1892
              )
            ]
            else_action:[]
            fi_kw:<KW_Fi fi>
          )
          (command.If
            if_kw:<KW_If if>
            arms:[
              (IfArm
                keyword:...0x1632
                cond:[
                  (command.Sentence
                    child:(command.DBracket
                      left:<KW_DLeftBracket "[[">
                      expr:(bool_expr.Binary
                        op_id:BoolBinary_GlobNEqual
                        left:(w
                          (BracedVarSub
                            left:<Left_DollarBrace "${">
                            name_tok:<VSub_Name words>
                            var_name:words
                            bracket_op:(bracket_op.WholeArray op_id:Arith_Star)
                            right:<Right_DollarBrace "}">
                          )
                        )
                        right:(w
                          <Lit_Other "*">
                          (word_part.EscapedLiteral
                            token:<Lit_EscapedChar "\\ ">
                            ch:" "
                          )
                          <Lit_Chars --prefix>
                          <BoolBinary_GlobEqual "=">
                          <Lit_Other "*">
                        )
                      )
                      right:<Lit_DRightBracket "]]">
                    )
                    terminator:<Op_Semi ";">
                  )
                ]
                then_kw:<KW_Then then>
                action:[
                  (C (w <Lit_Chars local>) (w <Lit_Chars REPLY>))
                  (C (w <Lit_Chars _comp_count_args>))
                  (command.AndOr
                    children:[
                      (command.DParen
                        left:<Op_DLeftParen "((">
                        child:(arith_expr.Binary
                          op:<Arith_Less "<">
                          left:<Lit_ArithVarLike REPLY>
                          right:(w <Lit_Digits 3>)
                        )
                        right:<Op_DRightParen ")">
                      )
                      (C
                        (w <Lit_Chars _comp_compgen_filedir>)
                        (w <Lit_Chars png>)
                      )
                    ]
                    ops:[<Op_DAmp "&&">]
                  )
                ]
                then_tok:...0x15a6
              )
            ]
            else_kw:<KW_Else else>
            else_action:[
              (C (w <Lit_Chars _comp_compgen_filedir>) (w <Lit_Chars png>))
            ]
            fi_kw:<KW_Fi fi>
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"_comp_cmd_zopflipng()\n{\n    local cur prev words cword was_split comp_args\n    _comp_initialize -s -- \"$@\" || return\n\n    case $prev in\n        -h | --help)\n            return\n            ;;\n        --splitting)\n            _comp_compgen -- -W '{0..3}'\n            return\n            ;;\n    esac\n\n    [[ $was_split ]] && return\n\n    if [[ $cur == -* ]]; then\n        _comp_compgen -R help -- -h\n        ((${#COMPREPLY[@]})) &&\n            _comp_compgen -- -W '\"${COMPREPLY[@]%:}\"'\n        [[ ${COMPREPLY-} == *= ]] && compopt -o nospace\n        return\n    fi\n\n    if [[ ${words[*]} != *\\ --prefix=* ]]; then\n        # 2 png args only if --prefix not given\n        local REPLY\n        _comp_count_args\n        ((REPLY < 3)) && _comp_compgen_filedir png\n    else\n        # otherwise arbitrary number of png args\n        _comp_compgen_filedir png\n    fi\n}"
    )
    (C
      (w <Lit_Chars complete>)
      (w <Lit_Chars -F>)
      (w <Lit_Chars _comp_cmd_zopflipng>)
      (w <Lit_Chars zopflipng>)
    )
  ]
  ops:[<Op_DAmp "&&">]
)
make[2]: *** [Makefile:1973: check-local] Error 2
make[2]: Leaving directory '/home/udu/aports/main/bash-completion/src/bash-completion-2.16.0/completions'
make[1]: *** [Makefile:1407: check-am] Error 2
make[1]: Leaving directory '/home/udu/aports/main/bash-completion/src/bash-completion-2.16.0/completions'
make: *** [Makefile:499: check-recursive] Error 1
>>> ERROR: bash-completion: check failed
>>> bash-completion: Uninstalling dependencies...
(1/41) Purging .makedepends-bash-completion (20251111.210153)
(2/41) Purging autoconf (2.72-r1)
(3/41) Purging m4 (1.4.19-r4)
(4/41) Purging automake (1.17-r1)
(5/41) Purging bc (1.08.2-r0)
(6/41) Purging grep (3.12-r0)
(7/41) Purging iputils (20240905-r0)
(8/41) Purging iputils-arping (20240905-r0)
(9/41) Purging iputils-clockdiff (20240905-r0)
(10/41) Purging iputils-ping (20240905-r0)
(11/41) Purging iputils-tracepath (20240905-r0)
(12/41) Purging psmisc (23.7-r0)
(13/41) Purging sed (4.9-r2)
Executing sed-4.9-r2.post-deinstall
(14/41) Purging usbutils (018-r0)
(15/41) Purging hwdata-usb (0.395-r0)
(16/41) Purging py3-pexpect-pyc (4.9-r1)
(17/41) Purging py3-pexpect (4.9-r1)
(18/41) Purging py3-ptyprocess-pyc (0.7.0-r6)
(19/41) Purging py3-ptyprocess (0.7.0-r6)
(20/41) Purging py3-pytest-pyc (8.3.5-r0)
(21/41) Purging py3-pytest (8.3.5-r0)
(22/41) Purging py3-iniconfig-pyc (2.1.0-r0)
(23/41) Purging py3-iniconfig (2.1.0-r0)
(24/41) Purging py3-packaging-pyc (25.0-r0)
(25/41) Purging py3-packaging (25.0-r0)
(26/41) Purging py3-parsing-pyc (3.2.3-r0)
(27/41) Purging py3-parsing (3.2.3-r0)
(28/41) Purging py3-pluggy-pyc (1.5.0-r0)
(29/41) Purging py3-pluggy (1.5.0-r0)
(30/41) Purging py3-py-pyc (1.11.0-r4)
(31/41) Purging py3-py (1.11.0-r4)
(32/41) Purging eudev-libs (3.2.14-r5)
(33/41) Purging git-perl (2.49.1-r0)
(34/41) Purging perl-git (2.49.1-r0)
(35/41) Purging perl-error (0.17030-r0)
(36/41) Purging perl (5.40.3-r0)
(37/41) Purging libusb (1.0.28-r0)
(38/41) Purging procps-ng (4.0.4-r3)
(39/41) Purging libproc2 (4.0.4-r3)
(40/41) Purging utmps-libs (0.1.3.1-r0)
(41/41) Purging skalibs-libs (2.14.4.0-r0)
Executing busybox-1.37.0-r19.trigger
OK: 296 MiB in 89 packages