(command.CommandList
  children: [
    (command.ShFunction
      name_tok: <_mplayer_options_list>
      name: _mplayer_options_list
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              left: <Id.Lit_VarLike 'cur='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'cur='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'cur='> name:cur)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (BracedVarSub
                        left: <Id.Left_DollarBrace '${'>
                        token: <Id.VSub_Name cur>
                        var_name: cur
                        suffix_op: 
                          (suffix_op.Unary
                            op: <Id.VOp1_Percent '%'>
                            arg_word: 
                              {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\\\'> ch:'\\')}
                          )
                        right: <Id.Right_DollarBrace '}'>
                      )
                    }
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'COMPREPLY='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'COMPREPLY='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'COMPREPLY='> name:COMPREPLY)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (ShArrayLiteral
                        left: <Id.Op_LParen _>
                        words: [
                          {
                            (CommandSub
                              left_token: <Id.Left_DollarParen '$('>
                              child: 
                                (command.Simple
                                  blame_tok: <compgen>
                                  more_env: []
                                  words: [
                                    {<compgen>}
                                    {<-W>}
                                    {
                                      (DQ 
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Pipeline
                                              children: [
                                                (command.Simple
                                                  blame_tok: <Id.VSub_Number '$1'>
                                                  more_env: []
                                                  words: [
                                                    {($ Id.VSub_Number 1)}
                                                    {<-nomsgcolor>}
                                                    {<-nomsgmodule>}
                                                    {($ Id.VSub_Number 2)}
                                                    {<help>}
                                                  ]
                                                  redirects: [
                                                    (Redir
                                                      op: <Id.Redir_Great '2>'>
                                                      loc: (redir_loc.Fd fd:2)
                                                      arg: {<'/dev/null'>}
                                                    )
                                                  ]
                                                  do_fork: T
                                                )
                                                (command.Simple
                                                  blame_tok: <sed>
                                                  more_env: []
                                                  words: [
                                                    {<sed>}
                                                    {<-e>}
                                                    {(SQ <'/^Available/,/^$/!d'>)}
                                                    {<-e>}
                                                    {(SQ <'/^Available/d'>)}
                                                  ]
                                                  redirects: []
                                                  do_fork: T
                                                )
                                                (command.Simple
                                                  blame_tok: <awk>
                                                  more_env: []
                                                  words: [{<awk>} {(SQ <'{print $1}'>)}]
                                                  redirects: []
                                                  do_fork: T
                                                )
                                                (command.Simple
                                                  blame_tok: <sed>
                                                  more_env: []
                                                  words: [
                                                    {<sed>}
                                                    {<-e>}
                                                    {(SQ <'s/:$//'>)}
                                                    {<-e>}
                                                    {(SQ <'s/^'>) 
                                                      (BracedVarSub
                                                        left: <Id.Left_DollarBrace '${'>
                                                        token: <Id.VSub_Number 2>
                                                        var_name: 2
                                                        suffix_op: 
                                                          (suffix_op.Unary
                                                            op: <Id.VOp1_Pound '#'>
                                                            arg_word: {<->}
                                                          )
                                                        right: <Id.Right_DollarBrace '}'>
                                                      ) (SQ <'$//'>)
                                                    }
                                                    {<-e>}
                                                    {(SQ <'s/<.*//'>)}
                                                  ]
                                                  redirects: []
                                                  do_fork: T
                                                )
                                              ]
                                              ops: [<Id.Op_Pipe _> <Id.Op_Pipe _> <Id.Op_Pipe _>]
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      )
                                    }
                                    {<-->}
                                    {(DQ ($ Id.VSub_DollarName cur))}
                                  ]
                                  redirects: []
                                  do_fork: T
                                )
                              right: <Id.Eof_RParen _>
                            )
                          }
                        ]
                        right: <Id.Right_ShArrayLiteral _>
                      )
                    }
                )
              ]
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.AndOr
      children: [
        (command.ShFunction
          name_tok: <_mplayer>
          name: _mplayer
          body: 
            (BraceGroup
              left: <Id.Lit_LBrace '{'>
              children: [
                (command.Simple
                  blame_tok: <local>
                  more_env: []
                  words: [{<local>} {<cur>} {<prev>} {<words>} {<cword>}]
                  redirects: []
                  do_fork: T
                )
                (command.AndOr
                  children: [
                    (command.Simple
                      blame_tok: <_init_completion>
                      more_env: []
                      words: [{<_init_completion>} {<-n>} {<Id.Lit_Colon ':'>}]
                      redirects: []
                      do_fork: T
                    )
                    (command.ControlFlow keyword:<Id.ControlFlow_Return return>)
                  ]
                  ops: [<Id.Op_DPipe _>]
                )
                (command.Simple
                  blame_tok: <local>
                  more_env: []
                  words: [
                    {<local>}
                    {<Id.Lit_VarLike 'cmd='> 
                      (BracedVarSub
                        left: <Id.Left_DollarBrace '${'>
                        token: <Id.VSub_Name words>
                        var_name: words
                        bracket_op: (bracket_op.ArrayIndex expr:{<Id.Lit_Digits 0>})
                        right: <Id.Right_DollarBrace '}'>
                      )
                    }
                    {<i>}
                    {<j>}
                    {<Id.Lit_VarLike 'k='> <0>}
                  ]
                  redirects: []
                  do_fork: T
                )
                (command.Case
                  case_kw: <Id.KW_Case case>
                  to_match: (case_arg.Word w:{($ Id.VSub_DollarName prev)})
                  arms_start: <Id.KW_In in>
                  arms: [
                    (CaseArm
                      left: <->
                      pattern: 
                        (pat.Words
                          words: [
                            {<-> <Id.Lit_LBracket '['> <av> <Id.Lit_RBracket ']'> <Id.Lit_LBracket '['> 
                              <cfo> <Id.Lit_RBracket ']'>
                            }
                            {<-> <Id.Lit_LBracket '['> <av> <Id.Lit_RBracket ']'> <fm>}
                            {<-vop>}
                            {<-fstype>}
                            {<-demuxer>}
                            {<-o> <Id.Lit_LBracket '['> <av> <Id.Lit_RBracket ']'> <c>}
                            {<-of>}
                            {<-profile>}
                            {<-audio-demuxer>}
                            {<-sub-demuxer>}
                          ]
                        )
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.Simple
                          blame_tok: <_mplayer_options_list>
                          more_env: []
                          words: [
                            {<_mplayer_options_list>}
                            {($ Id.VSub_DollarName cmd)}
                            {($ Id.VSub_DollarName prev)}
                          ]
                          redirects: []
                          do_fork: T
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-show-profile>
                      pattern: (pat.Words words:[{<-show-profile>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.Simple
                          blame_tok: <_mplayer_options_list>
                          more_env: []
                          words: [{<_mplayer_options_list>} {($ Id.VSub_DollarName cmd)} {<-profile>}]
                          redirects: []
                          do_fork: T
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-audiofile>
                      pattern: (pat.Words words:[{<-audiofile>} {<-audio-file>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.Simple
                          blame_tok: <_filedir>
                          more_env: []
                          words: [{<_filedir>} {(SQ <'@(mp3|mpg|ogg|w?(a)v|mid|flac|mka|ac3|ape)'>)}]
                          redirects: []
                          do_fork: T
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-font>
                      pattern: (pat.Words words:[{<-font>} {<-subfont>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.If
                          if_kw: <Id.KW_If if>
                          arms: [
                            (IfArm
                              keyword: <Id.KW_If if>
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          left: <Id.KW_DLeftBracket '[['>
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: {($ Id.VSub_DollarName prev)}
                                              right: {<-font>}
                                            )
                                          right: <Id.Lit_DRightBracket ']]'>
                                          redirects: []
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                )
                              then_kw: <Id.KW_Then then>
                              action: [
                                (command.Simple
                                  blame_tok: <_filedir>
                                  more_env: []
                                  words: [{<_filedir>} {(SQ <'@(desc|ttf)'>)}]
                                  redirects: []
                                  do_fork: T
                                )
                              ]
                              spids: [274 287]
                            )
                          ]
                          else_kw: <Id.KW_Else else>
                          else_action: [
                            (command.Simple
                              blame_tok: <_filedir>
                              more_env: []
                              words: [{<_filedir>} {<ttf>}]
                              redirects: []
                              do_fork: T
                            )
                          ]
                          fi_kw: <Id.KW_Fi fi>
                          redirects: []
                        )
                        (command.Simple
                          blame_tok: <local>
                          more_env: []
                          words: [
                            {<local>}
                            {<Id.Lit_VarLike 'IFS='> 
                              (SingleQuoted
                                left: <Id.Left_DollarSingleQuote '$\''>
                                tokens: [<Id.Char_OneChar '\\n'>]
                                right: <Id.Right_SingleQuote '\''>
                              )
                            }
                          ]
                          redirects: []
                          do_fork: T
                        )
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'COMPREPLY+='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'COMPREPLY+='>
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'COMPREPLY+='>
                                  name: COMPREPLY
                                )
                              op: assign_op.PlusEqual
                              rhs: 
                                {
                                  (ShArrayLiteral
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Simple
                                              blame_tok: <compgen>
                                              more_env: []
                                              words: [
                                                {<compgen>}
                                                {<-W>}
                                                {(SQ <'$( fc-list 2>/dev/null )'>)}
                                                {<-->}
                                                {(DQ ($ Id.VSub_DollarName cur))}
                                              ]
                                              redirects: []
                                              do_fork: T
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      }
                                    ]
                                    right: <Id.Right_ShArrayLiteral _>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-sub>
                      pattern: (pat.Words words:[{<-sub>} {<-sub-file>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.Simple
                          blame_tok: <_filedir>
                          more_env: []
                          words: [{<_filedir>} {(SQ <'@(srt|sub|txt|utf|rar|mpsub|smi|js|ssa|ass)'>)}]
                          redirects: []
                          do_fork: T
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-vobsub>
                      pattern: (pat.Words words:[{<-vobsub>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.Simple
                          blame_tok: <_filedir>
                          more_env: []
                          words: [{<_filedir>} {(SQ <'@(idx|ifo|sub)'>)}]
                          redirects: []
                          do_fork: T
                        )
                        (command.Simple
                          blame_tok: <local>
                          more_env: []
                          words: [
                            {<local>}
                            {<Id.Lit_VarLike 'IFS='> 
                              (SingleQuoted
                                left: <Id.Left_DollarSingleQuote '$\''>
                                tokens: [<Id.Char_OneChar '\\n'>]
                                right: <Id.Right_SingleQuote '\''>
                              )
                            }
                          ]
                          redirects: []
                          do_fork: T
                        )
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'COMPREPLY='>
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  name: COMPREPLY
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (ShArrayLiteral
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.ForEach
                                              keyword: <Id.KW_For for>
                                              iter_names: [i]
                                              iterable: 
                                                (for_iter.Words
                                                  words: [
                                                    {
                                                      (DQ 
                                                        (BracedVarSub
                                                          left: <Id.Left_DollarBrace '${'>
                                                          token: <Id.VSub_Name COMPREPLY>
                                                          var_name: COMPREPLY
                                                          bracket_op: 
                                                            (bracket_op.WholeArray
                                                              op_id: Id.Lit_At
                                                            )
                                                          right: <Id.Right_DollarBrace '}'>
                                                        )
                                                      )
                                                    }
                                                  ]
                                                )
                                              semi_tok: <Id.Op_Semi _>
                                              body: 
                                                (command.DoGroup
                                                  left: <Id.KW_Do do>
                                                  children: [
                                                    (command.If
                                                      if_kw: <Id.KW_If if>
                                                      arms: [
                                                        (IfArm
                                                          keyword: <Id.KW_If if>
                                                          cond: 
                                                            (condition.Shell
                                                              commands: [
                                                                (command.Sentence
                                                                  child: 
                                                                    (command.DBracket
                                                                      left: <Id.KW_DLeftBracket '[['>
                                                                      expr: 
                                                                        (bool_expr.LogicalAnd
                                                                          left: 
                                                                            (bool_expr.Unary
                                                                              op_id: Id.BoolUnary_f
                                                                              child: 
                                                                                {
                                                                                  ($ 
Id.VSub_DollarName i
                                                                                  )
                                                                                }
                                                                            )
                                                                          right: 
                                                                            (bool_expr.Unary
                                                                              op_id: Id.BoolUnary_r
                                                                              child: 
                                                                                {
                                                                                  ($ 
Id.VSub_DollarName i
                                                                                  )
                                                                                }
                                                                            )
                                                                        )
                                                                      right: 
                                                                        <Id.Lit_DRightBracket ']]'>
                                                                      redirects: []
                                                                    )
                                                                  terminator: <Id.Op_Semi _>
                                                                )
                                                              ]
                                                            )
                                                          then_kw: <Id.KW_Then then>
                                                          action: [
                                                            (command.Simple
                                                              blame_tok: <printf>
                                                              more_env: []
                                                              words: [
                                                                {<printf>}
                                                                {(SQ <'%s\\n'>)}
                                                                {
                                                                  (BracedVarSub
                                                                    left: <Id.Left_DollarBrace '${'>
                                                                    token: <Id.VSub_Name i>
                                                                    var_name: i
                                                                    suffix_op: 
                                                                      (suffix_op.Unary
                                                                        op: <Id.VOp1_Percent '%'>
                                                                        arg_word: 
                                                                          {<.> <Id.Lit_Other '*'>}
                                                                      )
                                                                    right: <Id.Right_DollarBrace '}'>
                                                                  )
                                                                }
                                                              ]
                                                              redirects: []
                                                              do_fork: T
                                                            )
                                                          ]
                                                          spids: [412 429]
                                                        )
                                                      ]
                                                      else_kw: <Id.KW_Else else>
                                                      else_action: [
                                                        (command.Simple
                                                          blame_tok: <printf>
                                                          more_env: []
                                                          words: [
                                                            {<printf>}
                                                            {(SQ <'%s\\n'>)}
                                                            {($ Id.VSub_DollarName i)}
                                                          ]
                                                          redirects: []
                                                          do_fork: T
                                                        )
                                                      ]
                                                      fi_kw: <Id.KW_Fi fi>
                                                      redirects: []
                                                    )
                                                  ]
                                                  right: <Id.KW_Done done>
                                                )
                                              redirects: []
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      }
                                    ]
                                    right: <Id.Right_ShArrayLiteral _>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-subcp>
                      pattern: (pat.Words words:[{<-subcp>} {<-msgcharset>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.Simple
                          blame_tok: <local>
                          more_env: []
                          words: [{<local>} {<cp>}]
                          redirects: []
                          do_fork: T
                        )
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'cp='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'cp='>
                              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'cp='> name:cp)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (ShArrayLiteral
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Pipeline
                                              children: [
                                                (command.Simple
                                                  blame_tok: <iconv>
                                                  more_env: []
                                                  words: [{<iconv>} {<--list>}]
                                                  redirects: [
                                                    (Redir
                                                      op: <Id.Redir_Great '2>'>
                                                      loc: (redir_loc.Fd fd:2)
                                                      arg: {<'/dev/null'>}
                                                    )
                                                  ]
                                                  do_fork: T
                                                )
                                                (command.Simple
                                                  blame_tok: <sed>
                                                  more_env: []
                                                  words: [{<sed>} {<-e>} {(DQ <'s@//@@;'>)}]
                                                  redirects: [
                                                    (Redir
                                                      op: <Id.Redir_Great '2>'>
                                                      loc: (redir_loc.Fd fd:2)
                                                      arg: {<'/dev/null'>}
                                                    )
                                                  ]
                                                  do_fork: T
                                                )
                                              ]
                                              ops: [<Id.Op_Pipe _>]
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      }
                                    ]
                                    right: <Id.Right_ShArrayLiteral _>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.If
                          if_kw: <Id.KW_If if>
                          arms: [
                            (IfArm
                              keyword: <Id.KW_If if>
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          left: <Id.KW_DLeftBracket '[['>
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: {(DQ ($ Id.VSub_DollarName cur))}
                                              right: 
                                                {
                                                  (DQ 
                                                    (BracedVarSub
                                                      left: <Id.Left_DollarBrace '${'>
                                                      token: <Id.VSub_Name cur>
                                                      var_name: cur
                                                      suffix_op: 
                                                        (suffix_op.Unary
                                                          op: <Id.VOp1_DComma ',,'>
                                                          arg_word: {}
                                                        )
                                                      right: <Id.Right_DollarBrace '}'>
                                                    )
                                                  )
                                                }
                                            )
                                          right: <Id.Lit_DRightBracket ']]'>
                                          redirects: []
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                )
                              then_kw: <Id.KW_Then then>
                              action: [
                                (command.ShAssignment
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  pairs: [
                                    (AssignPair
                                      left: <Id.Lit_VarLike 'COMPREPLY='>
                                      lhs: 
                                        (sh_lhs_expr.Name
                                          left: <Id.Lit_VarLike 'COMPREPLY='>
                                          name: COMPREPLY
                                        )
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (ShArrayLiteral
                                            left: <Id.Op_LParen _>
                                            words: [
                                              {
                                                (CommandSub
                                                  left_token: <Id.Left_DollarParen '$('>
                                                  child: 
                                                    (command.Simple
                                                      blame_tok: <compgen>
                                                      more_env: []
                                                      words: [
                                                        {<compgen>}
                                                        {<-W>}
                                                        {(SQ <'${cp[@],,}'>)}
                                                        {<-->}
                                                        {(DQ ($ Id.VSub_DollarName cur))}
                                                      ]
                                                      redirects: []
                                                      do_fork: T
                                                    )
                                                  right: <Id.Eof_RParen _>
                                                )
                                              }
                                            ]
                                            right: <Id.Right_ShArrayLiteral _>
                                          )
                                        }
                                    )
                                  ]
                                  redirects: []
                                )
                              ]
                              spids: [517 537]
                            )
                          ]
                          else_kw: <Id.KW_Else else>
                          else_action: [
                            (command.ShAssignment
                              left: <Id.Lit_VarLike 'COMPREPLY='>
                              pairs: [
                                (AssignPair
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'COMPREPLY='>
                                      name: COMPREPLY
                                    )
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (ShArrayLiteral
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {
                                            (CommandSub
                                              left_token: <Id.Left_DollarParen '$('>
                                              child: 
                                                (command.Simple
                                                  blame_tok: <compgen>
                                                  more_env: []
                                                  words: [
                                                    {<compgen>}
                                                    {<-W>}
                                                    {(SQ <'${cp[@]^^}'>)}
                                                    {<-->}
                                                    {(DQ ($ Id.VSub_DollarName cur))}
                                                  ]
                                                  redirects: []
                                                  do_fork: T
                                                )
                                              right: <Id.Eof_RParen _>
                                            )
                                          }
                                        ]
                                        right: <Id.Right_ShArrayLiteral _>
                                      )
                                    }
                                )
                              ]
                              redirects: []
                            )
                          ]
                          fi_kw: <Id.KW_Fi fi>
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-ifo>
                      pattern: (pat.Words words:[{<-ifo>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.Simple
                          blame_tok: <_filedir>
                          more_env: []
                          words: [{<_filedir>} {<ifo>}]
                          redirects: []
                          do_fork: T
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-cuefile>
                      pattern: (pat.Words words:[{<-cuefile>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.Simple
                          blame_tok: <_filedir>
                          more_env: []
                          words: [{<_filedir>} {(SQ <'@(bin|cue)'>)}]
                          redirects: []
                          do_fork: T
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-skin>
                      pattern: (pat.Words words:[{<-skin>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.Simple
                          blame_tok: <local>
                          more_env: []
                          words: [{<local>} {<-a>} {<dirs>}]
                          redirects: []
                          do_fork: T
                        )
                        (command.If
                          if_kw: <Id.KW_If if>
                          arms: [
                            (IfArm
                              keyword: <Id.KW_If if>
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          left: <Id.KW_DLeftBracket '[['>
                                          expr: 
                                            (bool_expr.Unary
                                              op_id: Id.BoolUnary_n
                                              child: {($ Id.VSub_DollarName MPLAYER_SKINS_DIR)}
                                            )
                                          right: <Id.Lit_DRightBracket ']]'>
                                          redirects: []
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                )
                              then_kw: <Id.KW_Then then>
                              action: [
                                (command.ShAssignment
                                  left: <Id.Lit_VarLike 'dirs='>
                                  pairs: [
                                    (AssignPair
                                      left: <Id.Lit_VarLike 'dirs='>
                                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'dirs='> name:dirs)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (ShArrayLiteral
                                            left: <Id.Op_LParen _>
                                            words: [{($ Id.VSub_DollarName MPLAYER_SKINS_DIR)}]
                                            right: <Id.Right_ShArrayLiteral _>
                                          )
                                        }
                                    )
                                  ]
                                  redirects: []
                                )
                              ]
                              spids: [657 668]
                            )
                          ]
                          else_kw: <Id.KW_Else else>
                          else_action: [
                            (command.ShAssignment
                              left: <Id.Lit_VarLike 'dirs='>
                              pairs: [
                                (AssignPair
                                  left: <Id.Lit_VarLike 'dirs='>
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'dirs='> name:dirs)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (ShArrayLiteral
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {<'/usr/share/mplayer/skins'>}
                                          {<'/usr/local/share/mplayer/skins'>}
                                        ]
                                        right: <Id.Right_ShArrayLiteral _>
                                      )
                                    }
                                )
                              ]
                              redirects: []
                            )
                          ]
                          fi_kw: <Id.KW_Fi fi>
                          redirects: []
                        )
                        (command.Simple
                          blame_tok: <local>
                          more_env: []
                          words: [
                            {<local>}
                            {<Id.Lit_VarLike 'IFS='> 
                              (SingleQuoted
                                left: <Id.Left_DollarSingleQuote '$\''>
                                tokens: [<Id.Char_OneChar '\\n'>]
                                right: <Id.Right_SingleQuote '\''>
                              )
                            }
                          ]
                          redirects: []
                          do_fork: T
                        )
                        (command.ForEach
                          keyword: <Id.KW_For for>
                          iter_names: [i]
                          iterable: 
                            (for_iter.Words
                              words: [
                                {(word_part.TildeSub token:<Id.Lit_TildeLike '~'>) 
                                  <'/.mplayer/skins'>
                                }
                                {
                                  (BracedVarSub
                                    left: <Id.Left_DollarBrace '${'>
                                    token: <Id.VSub_Name dirs>
                                    var_name: dirs
                                    bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                    right: <Id.Right_DollarBrace '}'>
                                  )
                                }
                              ]
                            )
                          semi_tok: <Id.Op_Semi _>
                          body: 
                            (command.DoGroup
                              left: <Id.KW_Do do>
                              children: [
                                (command.If
                                  if_kw: <Id.KW_If if>
                                  arms: [
                                    (IfArm
                                      keyword: <Id.KW_If if>
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (command.Sentence
                                              child: 
                                                (command.DBracket
                                                  left: <Id.KW_DLeftBracket '[['>
                                                  expr: 
                                                    (bool_expr.LogicalAnd
                                                      left: 
                                                        (bool_expr.Unary
                                                          op_id: Id.BoolUnary_d
                                                          child: {($ Id.VSub_DollarName i)}
                                                        )
                                                      right: 
                                                        (bool_expr.Unary
                                                          op_id: Id.BoolUnary_r
                                                          child: {($ Id.VSub_DollarName i)}
                                                        )
                                                    )
                                                  right: <Id.Lit_DRightBracket ']]'>
                                                  redirects: []
                                                )
                                              terminator: <Id.Op_Semi _>
                                            )
                                          ]
                                        )
                                      then_kw: <Id.KW_Then then>
                                      action: [
                                        (command.ForEach
                                          keyword: <Id.KW_For for>
                                          iter_names: [j]
                                          iterable: 
                                            (for_iter.Words
                                              words: [
                                                {
                                                  (CommandSub
                                                    left_token: <Id.Left_DollarParen '$('>
                                                    child: 
                                                      (command.Simple
                                                        blame_tok: <compgen>
                                                        more_env: []
                                                        words: [
                                                          {<compgen>}
                                                          {<-d>}
                                                          {<-->}
                                                          {($ Id.VSub_DollarName i) <'/'> 
                                                            ($ Id.VSub_DollarName cur)
                                                          }
                                                        ]
                                                        redirects: []
                                                        do_fork: T
                                                      )
                                                    right: <Id.Eof_RParen _>
                                                  )
                                                }
                                              ]
                                            )
                                          semi_tok: <Id.Op_Semi _>
                                          body: 
                                            (command.DoGroup
                                              left: <Id.KW_Do do>
                                              children: [
                                                (command.ShAssignment
                                                  left: <Id.Lit_ArrayLhsOpen 'COMPREPLY['>
                                                  pairs: [
                                                    (AssignPair
                                                      left: <Id.Lit_ArrayLhsOpen 'COMPREPLY['>
                                                      lhs: 
                                                        (sh_lhs_expr.IndexedName
                                                          left: <Id.Lit_ArrayLhsOpen 'COMPREPLY['>
                                                          name: COMPREPLY
                                                          index: {($ Id.VSub_DollarName k)}
                                                        )
                                                      op: assign_op.Equal
                                                      rhs: 
                                                        {
                                                          (BracedVarSub
                                                            left: <Id.Left_DollarBrace '${'>
                                                            token: <Id.VSub_Name j>
                                                            var_name: j
                                                            suffix_op: 
                                                              (suffix_op.Unary
                                                                op: <Id.VOp1_Pound '#'>
                                                                arg_word: 
                                                                  {($ Id.VSub_DollarName i) 
                                                                    <Id.Lit_Slash '/'>
                                                                  }
                                                              )
                                                            right: <Id.Right_DollarBrace '}'>
                                                          )
                                                        }
                                                    )
                                                  ]
                                                  redirects: []
                                                )
                                                (command.ShAssignment
                                                  left: <Id.Lit_VarLike 'k='>
                                                  pairs: [
                                                    (AssignPair
                                                      left: <Id.Lit_VarLike 'k='>
                                                      lhs: 
                                                        (sh_lhs_expr.Name
                                                          left: <Id.Lit_VarLike 'k='>
                                                          name: k
                                                        )
                                                      op: assign_op.Equal
                                                      rhs: 
                                                        {
                                                          (word_part.ArithSub
                                                            left: <Id.Left_DollarDParen '$(('>
                                                            anode: 
                                                              (arith_expr.UnaryAssign
                                                                op_id: Id.Arith_DPlus
                                                                child: ($ Id.Lit_ArithVarLike k)
                                                              )
                                                            right: <Id.Right_DollarDParen _>
                                                          )
                                                        }
                                                    )
                                                  ]
                                                  redirects: []
                                                )
                                              ]
                                              right: <Id.KW_Done done>
                                            )
                                          redirects: []
                                        )
                                      ]
                                      spids: [720 737]
                                    )
                                  ]
                                  else_action: []
                                  fi_kw: <Id.KW_Fi fi>
                                  redirects: []
                                )
                              ]
                              right: <Id.KW_Done done>
                            )
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-cdrom-device>
                      pattern: (pat.Words words:[{<-cdrom-device>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.Simple
                          blame_tok: <_cd_devices>
                          more_env: []
                          words: [{<_cd_devices>}]
                          redirects: []
                          do_fork: T
                        )
                        (command.Simple
                          blame_tok: <_dvd_devices>
                          more_env: []
                          words: [{<_dvd_devices>}]
                          redirects: []
                          do_fork: T
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-dvd-device>
                      pattern: (pat.Words words:[{<-dvd-device>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.Simple
                          blame_tok: <_dvd_devices>
                          more_env: []
                          words: [{<_dvd_devices>}]
                          redirects: []
                          do_fork: T
                        )
                        (command.Simple
                          blame_tok: <_filedir>
                          more_env: []
                          words: [{<_filedir>} {<iso>}]
                          redirects: []
                          do_fork: T
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-bluray-device>
                      pattern: (pat.Words words:[{<-bluray-device>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.Simple
                          blame_tok: <_filedir>
                          more_env: []
                          words: [{<_filedir>} {<-d>}]
                          redirects: []
                          do_fork: T
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-mixer>
                      pattern: (pat.Words words:[{<-mixer>} {<-dvdauth>} {<-fb>} {<-zrdev>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'cur='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'cur='>
                              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'cur='> name:cur)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (BracedVarSub
                                    left: <Id.Left_DollarBrace '${'>
                                    token: <Id.VSub_Name cur>
                                    var_name: cur
                                    suffix_op: 
                                      (suffix_op.Unary
                                        op: <Id.VTest_ColonEquals _>
                                        arg_word: {<Id.Lit_Slash '/'> <dev> <Id.Lit_Slash '/'>}
                                      )
                                    right: <Id.Right_DollarBrace '}'>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.Simple
                          blame_tok: <_filedir>
                          more_env: []
                          words: [{<_filedir>}]
                          redirects: []
                          do_fork: T
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-edl>
                      pattern: 
                        (pat.Words
                          words: [
                            {<-edl>}
                            {<-edlout>}
                            {<-lircconf>}
                            {<-menu-cfg>}
                            {<-playlist>}
                            {<-csslib>}
                            {<-dumpfile>}
                            {<-subfile>}
                            {<-vobsub>}
                            {<-aofile>}
                            {<-fbmodeconfig>}
                            {<-include>}
                            {<-o>}
                            {<-dvdkey>}
                            {<-passlogfile>}
                          ]
                        )
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.Simple
                          blame_tok: <_filedir>
                          more_env: []
                          words: [{<_filedir>}]
                          redirects: []
                          do_fork: T
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-autoq>
                      pattern: 
                        (pat.Words
                          words: [
                            {<-autoq>}
                            {<-autosync>}
                            {<-loop>}
                            {<-menu-root>}
                            {<-speed>}
                            {<-sstep>}
                            {<-aid>}
                            {<-alang>}
                            {<-bandwidth>}
                            {<-bluray-angle>}
                            {<-bluray-chapter>}
                            {<-cache>}
                            {<-chapter>}
                            {<-dvd-speed>}
                            {<-dvdangle>}
                            {<-fps>}
                            {<-frames>}
                            {<-mc>}
                            {<-passwd>}
                            {<-user>}
                            {<-sb>}
                            {<-srate>}
                            {<-ss>}
                            {<-vcd>}
                            {<-vi>}
                            {<-vid>}
                            {<-vivo>}
                            {<-ffactor>}
                            {<-sid>}
                            {<-slang>}
                            {<-spualign>}
                            {<-spuaa>}
                            {<-spugauss>}
                            {<-vobsubid>}
                            {<-delay>}
                            {<-bpp>}
                            {<-brightness>}
                            {<-contrast>}
                            {<-dfbopts>}
                            {<-display>}
                            {<-fbmode>}
                            {<-geometry>}
                            {<-guiwid>}
                            {<-hue>}
                            {<-icelayer>}
                            {<-screen> <Id.Lit_LBracket '['> <wh> <Id.Lit_RBracket ']'>}
                            {<-wid>}
                            {<-monitor-dotclock>}
                            {<-monitor-> <Id.Lit_LBracket '['> <hv> <Id.Lit_RBracket ']'> <freq>}
                            {<-panscan>}
                            {<-saturation>}
                            {<-xineramascreen>}
                            {<-zrcrop>}
                            {<-zrnorm>}
                            {<-zrquality>}
                            {<-zr> <Id.Lit_LBracket '['> <xy> <Id.Lit_RBracket ']'> <doff>}
                            {<-zr> <Id.Lit_LBracket '['> <vh> <Id.Lit_RBracket ']'> <dec>}
                            {<-pp>}
                            {<-x>}
                            {<-y>}
                            {<-xy>}
                            {<-z>}
                            {<-stereo>}
                            {<-audio-density>}
                            {<-audio-delay>}
                            {<-audio-preload>}
                            {<-endpos>}
                            {<-osdlevel>}
                            {<-ffourcc>}
                            {<-sws>}
                            {<-skiplimit>}
                            {<-format>}
                            {<-ofps>}
                            {<-aadriver>}
                            {<-aaosdcolor>}
                            {<-aasubcolor>}
                            {<-vobsubout>}
                            {<-vobsuboutid>}
                            {<-vobsuboutindex>}
                            {<-sub-bg-alpha>}
                            {<-sub-bg-color>}
                            {<-subdelay>}
                            {<-subfps>}
                            {<-subpos>}
                            {<-subalign>}
                            {<-subwidth>}
                            {<-subfont-blur>}
                            {<-subfont-outline>}
                            {<-subfont-autoscale>}
                            {<-subfont-encoding>}
                            {<-subfont-osd-scale>}
                            {<-subfont-text-scale>}
                          ]
                        )
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-channels>
                      pattern: (pat.Words words:[{<-channels>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'COMPREPLY='>
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  name: COMPREPLY
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (ShArrayLiteral
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Simple
                                              blame_tok: <compgen>
                                              more_env: []
                                              words: [
                                                {<compgen>}
                                                {<-W>}
                                                {(SQ <'2 4 6 8'>)}
                                                {<-->}
                                                {(DQ ($ Id.VSub_DollarName cur))}
                                              ]
                                              redirects: []
                                              do_fork: T
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      }
                                    ]
                                    right: <Id.Right_ShArrayLiteral _>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-aspect>
                      pattern: (pat.Words words:[{<-aspect>} {<-monitoraspect>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'COMPREPLY='>
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  name: COMPREPLY
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (ShArrayLiteral
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Simple
                                              blame_tok: <compgen>
                                              more_env: []
                                              words: [
                                                {<compgen>}
                                                {<-W>}
                                                {
                                                  (SQ <'1:1 3:2 4:3 5:4 14:9 14:10 16:9 16:10\n'> 
                                                    <'                2.35:1'>
                                                  )
                                                }
                                                {<-->}
                                                {(DQ ($ Id.VSub_DollarName cur))}
                                              ]
                                              redirects: []
                                              do_fork: T
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      }
                                    ]
                                    right: <Id.Right_ShArrayLiteral _>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.Simple
                          blame_tok: <__ltrim_colon_completions>
                          more_env: []
                          words: [{<__ltrim_colon_completions>} {(DQ ($ Id.VSub_DollarName cur))}]
                          redirects: []
                          do_fork: T
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-lavdopts>
                      pattern: (pat.Words words:[{<-lavdopts>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'COMPREPLY='>
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  name: COMPREPLY
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (ShArrayLiteral
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Simple
                                              blame_tok: <compgen>
                                              more_env: []
                                              words: [
                                                {<compgen>}
                                                {<-W>}
                                                {
                                                  (SQ <'bitexact bug= debug= ec= er= fast gray\n'> 
                                                    <
'                idct= lowres= sb= st= skiploopfilter= skipidct= skipframe=\n'
                                                    > <'                threads= vismv= vstats'>
                                                  )
                                                }
                                                {<-->}
                                                {(DQ ($ Id.VSub_DollarName cur))}
                                              ]
                                              redirects: []
                                              do_fork: T
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      }
                                    ]
                                    right: <Id.Right_ShArrayLiteral _>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-lavcopts>
                      pattern: (pat.Words words:[{<-lavcopts>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'COMPREPLY='>
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  name: COMPREPLY
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (ShArrayLiteral
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Simple
                                              blame_tok: <compgen>
                                              more_env: []
                                              words: [
                                                {<compgen>}
                                                {<-W>}
                                                {
                                                  (SQ <'vcodec= vqmin= vqscale= vqmax= mbqmin=\n'> 
                                                    <
'                mbqmax= vqdiff= vmax_b_frames= vme= vhq v4mv keyint=\n'
                                                    > <'                vb_strategy= vpass= aspect= vbitrate= vratetol= vrc_maxrate=\n'> 
                                                    <
'                vrc_minrate= vrc_buf_size= vb_qfactor= vi_qfactor= vb_qoffset=\n'
                                                    > <'                vi_qoffset= vqblur= vqcomp= vrc_eq= vrc_override=\n'> 
                                                    <
'                vrc_init_cplx= vqsquish= vlelim= vcelim= vstrict= vdpart\n'
                                                    > <'                vpsize= gray vfdct= idct= lumi_mask= dark_mask= tcplx_mask=\n'> 
                                                    <
'                scplx_mask= naq ildct format= pred qpel precmp= cmp= subcmp=\n'
                                                    > <'                predia= dia= trell last_pred= preme= subq= psnr mpeg_quant aic\n'> 
                                                    <'                umv'>
                                                  )
                                                }
                                                {<-->}
                                                {(DQ ($ Id.VSub_DollarName cur))}
                                              ]
                                              redirects: []
                                              do_fork: T
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      }
                                    ]
                                    right: <Id.Right_ShArrayLiteral _>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-ssf>
                      pattern: (pat.Words words:[{<-ssf>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'COMPREPLY='>
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  name: COMPREPLY
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (ShArrayLiteral
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Simple
                                              blame_tok: <compgen>
                                              more_env: []
                                              words: [
                                                {<compgen>}
                                                {<-W>}
                                                {(SQ <'lgb= cgb= ls= cs= chs= cvs='>)}
                                                {<-->}
                                                {(DQ ($ Id.VSub_DollarName cur))}
                                              ]
                                              redirects: []
                                              do_fork: T
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      }
                                    ]
                                    right: <Id.Right_ShArrayLiteral _>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-jpeg>
                      pattern: (pat.Words words:[{<-jpeg>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'COMPREPLY='>
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  name: COMPREPLY
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (ShArrayLiteral
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Simple
                                              blame_tok: <compgen>
                                              more_env: []
                                              words: [
                                                {<compgen>}
                                                {<-W>}
                                                {
                                                  (SQ <'noprogressive progressive nobaseline\n'> 
                                                    <
'                baseline optimize= smooth= quality= outdir='
                                                    >
                                                  )
                                                }
                                                {<-->}
                                                {(DQ ($ Id.VSub_DollarName cur))}
                                              ]
                                              redirects: []
                                              do_fork: T
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      }
                                    ]
                                    right: <Id.Right_ShArrayLiteral _>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-xvidopts>
                      pattern: (pat.Words words:[{<-xvidopts>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'COMPREPLY='>
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  name: COMPREPLY
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (ShArrayLiteral
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Simple
                                              blame_tok: <compgen>
                                              more_env: []
                                              words: [
                                                {<compgen>}
                                                {<-W>}
                                                {(SQ <'dr2 nodr2'>)}
                                                {<-->}
                                                {(DQ ($ Id.VSub_DollarName cur))}
                                              ]
                                              redirects: []
                                              do_fork: T
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      }
                                    ]
                                    right: <Id.Right_ShArrayLiteral _>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-xvidencopts>
                      pattern: (pat.Words words:[{<-xvidencopts>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'COMPREPLY='>
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  name: COMPREPLY
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (ShArrayLiteral
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Simple
                                              blame_tok: <compgen>
                                              more_env: []
                                              words: [
                                                {<compgen>}
                                                {<-W>}
                                                {
                                                  (SQ <'pass= bitrate= fixed_quant= me_quality=\n'> 
                                                    <
'                4mv rc_reaction_delay_factor= rc_averaging_period= rc_buffer=\n'
                                                    > <'                quant_range= min_key_interval= max_key_interval= mpeg_quant\n'> 
                                                    <
'                mod_quant lumi_mask hintedme hintfile debug keyframe_boost=\n'
                                                    > <'                kfthreshold= kfreduction='>
                                                  )
                                                }
                                                {<-->}
                                                {(DQ ($ Id.VSub_DollarName cur))}
                                              ]
                                              redirects: []
                                              do_fork: T
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      }
                                    ]
                                    right: <Id.Right_ShArrayLiteral _>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-divx4opts>
                      pattern: (pat.Words words:[{<-divx4opts>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'COMPREPLY='>
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  name: COMPREPLY
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (ShArrayLiteral
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Simple
                                              blame_tok: <compgen>
                                              more_env: []
                                              words: [
                                                {<compgen>}
                                                {<-W>}
                                                {
                                                  (SQ <'br= key= deinterlace q= min_quant=\n'> 
                                                    <
'                max_quant= rc_period= rc_reaction_period= crispness=\n'
                                                    > <'                rc_reaction_ratio= pass= vbrpass= help'>
                                                  )
                                                }
                                                {<-->}
                                                {(DQ ($ Id.VSub_DollarName cur))}
                                              ]
                                              redirects: []
                                              do_fork: T
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      }
                                    ]
                                    right: <Id.Right_ShArrayLiteral _>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-info>
                      pattern: (pat.Words words:[{<-info>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'COMPREPLY='>
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  name: COMPREPLY
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (ShArrayLiteral
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Simple
                                              blame_tok: <compgen>
                                              more_env: []
                                              words: [
                                                {<compgen>}
                                                {<-W>}
                                                {
                                                  (SQ <'name= artist= genre= subject=\n'> 
                                                    <
'                copyright= srcform= comment= help'
                                                    >
                                                  )
                                                }
                                                {<-->}
                                                {(DQ ($ Id.VSub_DollarName cur))}
                                              ]
                                              redirects: []
                                              do_fork: T
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      }
                                    ]
                                    right: <Id.Right_ShArrayLiteral _>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-lameopts>
                      pattern: (pat.Words words:[{<-lameopts>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'COMPREPLY='>
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  name: COMPREPLY
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (ShArrayLiteral
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Simple
                                              blame_tok: <compgen>
                                              more_env: []
                                              words: [
                                                {<compgen>}
                                                {<-W>}
                                                {
                                                  (SQ <'vbr= abr cbr br= q= aq= ratio= vol=\n'> 
                                                    <
'                mode= padding= fast preset= help'
                                                    >
                                                  )
                                                }
                                                {<-->}
                                                {(DQ ($ Id.VSub_DollarName cur))}
                                              ]
                                              redirects: []
                                              do_fork: T
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      }
                                    ]
                                    right: <Id.Right_ShArrayLiteral _>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-rawaudio>
                      pattern: (pat.Words words:[{<-rawaudio>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'COMPREPLY='>
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  name: COMPREPLY
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (ShArrayLiteral
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Simple
                                              blame_tok: <compgen>
                                              more_env: []
                                              words: [
                                                {<compgen>}
                                                {<-W>}
                                                {(SQ <'on channels= rate= samplesize= format='>)}
                                                {<-->}
                                                {(DQ ($ Id.VSub_DollarName cur))}
                                              ]
                                              redirects: []
                                              do_fork: T
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      }
                                    ]
                                    right: <Id.Right_ShArrayLiteral _>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-rawvideo>
                      pattern: (pat.Words words:[{<-rawvideo>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'COMPREPLY='>
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  name: COMPREPLY
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (ShArrayLiteral
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Simple
                                              blame_tok: <compgen>
                                              more_env: []
                                              words: [
                                                {<compgen>}
                                                {<-W>}
                                                {
                                                  (SQ <'on fps= sqcif qcif cif 4cif pal ntsc w=\n'> 
                                                    <
'                h= y420 yv12 yuy2 y8 format= size='
                                                    >
                                                  )
                                                }
                                                {<-->}
                                                {(DQ ($ Id.VSub_DollarName cur))}
                                              ]
                                              redirects: []
                                              do_fork: T
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      }
                                    ]
                                    right: <Id.Right_ShArrayLiteral _>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-aop>
                      pattern: (pat.Words words:[{<-aop>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'COMPREPLY='>
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  name: COMPREPLY
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (ShArrayLiteral
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Simple
                                              blame_tok: <compgen>
                                              more_env: []
                                              words: [
                                                {<compgen>}
                                                {<-W>}
                                                {
                                                  (SQ <'list= delay= format= fout= volume= mul=\n'> 
                                                    <'                softclip'>
                                                  )
                                                }
                                                {<-->}
                                                {(DQ ($ Id.VSub_DollarName cur))}
                                              ]
                                              redirects: []
                                              do_fork: T
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      }
                                    ]
                                    right: <Id.Right_ShArrayLiteral _>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-dxr2>
                      pattern: (pat.Words words:[{<-dxr2>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'COMPREPLY='>
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  name: COMPREPLY
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (ShArrayLiteral
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Simple
                                              blame_tok: <compgen>
                                              more_env: []
                                              words: [
                                                {<compgen>}
                                                {<-W>}
                                                {
                                                  (SQ <'ar-mode= iec958-encoded iec958-decoded\n'> 
                                                    <
'                mute ucode= 75ire bw color interlaced macrovision= norm=\n'
                                                    > <'                square-pixel ccir601-pixel cr-left= cr-right= cr-top= cr-bot=\n'> 
                                                    <
'                ck-rmin= ck-gmin= ck-bmin= ck-rmax= ck-gmax= ck-bmax= ck-r=\n'
                                                    > <'                ck-g= ck-b= ignore-cache= ol-osd= olh-cor= olw-cor= olx-cor=\n'> 
                                                    <
'                oly-cor= overlay overlay-ratio= update-cache'
                                                    >
                                                  )
                                                }
                                                {<-->}
                                                {(DQ ($ Id.VSub_DollarName cur))}
                                              ]
                                              redirects: []
                                              do_fork: T
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      }
                                    ]
                                    right: <Id.Right_ShArrayLiteral _>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-tv>
                      pattern: (pat.Words words:[{<-tv>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'COMPREPLY='>
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  name: COMPREPLY
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (ShArrayLiteral
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Simple
                                              blame_tok: <compgen>
                                              more_env: []
                                              words: [
                                                {<compgen>}
                                                {<-W>}
                                                {
                                                  (SQ <'on noaudio driver= device= input= freq=\n'> 
                                                    <
'                outfmt= width= height= buffersize= norm= channel= chanlist=\n'
                                                    > <'                audiorate= forceaudio alsa amode= forcechan= adevice= audioid=\n'> 
                                                    <
'                volume= bass= treble= balance= fps= channels= immediatemode='
                                                    >
                                                  )
                                                }
                                                {<-->}
                                                {(DQ ($ Id.VSub_DollarName cur))}
                                              ]
                                              redirects: []
                                              do_fork: T
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      }
                                    ]
                                    right: <Id.Right_ShArrayLiteral _>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-mf>
                      pattern: (pat.Words words:[{<-mf>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'COMPREPLY='>
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  name: COMPREPLY
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (ShArrayLiteral
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Simple
                                              blame_tok: <compgen>
                                              more_env: []
                                              words: [
                                                {<compgen>}
                                                {<-W>}
                                                {(SQ <'on w= h= fps= type='>)}
                                                {<-->}
                                                {(DQ ($ Id.VSub_DollarName cur))}
                                              ]
                                              redirects: []
                                              do_fork: T
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      }
                                    ]
                                    right: <Id.Right_ShArrayLiteral _>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-cdda>
                      pattern: (pat.Words words:[{<-cdda>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'COMPREPLY='>
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  name: COMPREPLY
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (ShArrayLiteral
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Simple
                                              blame_tok: <compgen>
                                              more_env: []
                                              words: [
                                                {<compgen>}
                                                {<-W>}
                                                {
                                                  (SQ <'speed= paranoia= generic-dev=\n'> 
                                                    <
'                sector-size= overlap= toc-bias toc-offset= skip noskip'
                                                    >
                                                  )
                                                }
                                                {<-->}
                                                {(DQ ($ Id.VSub_DollarName cur))}
                                              ]
                                              redirects: []
                                              do_fork: T
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      }
                                    ]
                                    right: <Id.Right_ShArrayLiteral _>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-input>
                      pattern: (pat.Words words:[{<-input>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'COMPREPLY='>
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  name: COMPREPLY
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (ShArrayLiteral
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Simple
                                              blame_tok: <compgen>
                                              more_env: []
                                              words: [
                                                {<compgen>}
                                                {<-W>}
                                                {
                                                  (SQ <'conf= ar-delay ar-rate keylist cmdlist\n'> 
                                                    <'                js-dev file'>
                                                  )
                                                }
                                                {<-->}
                                                {(DQ ($ Id.VSub_DollarName cur))}
                                              ]
                                              redirects: []
                                              do_fork: T
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      }
                                    ]
                                    right: <Id.Right_ShArrayLiteral _>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-af-adv>
                      pattern: (pat.Words words:[{<-af-adv>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'COMPREPLY='>
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  name: COMPREPLY
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (ShArrayLiteral
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Simple
                                              blame_tok: <compgen>
                                              more_env: []
                                              words: [
                                                {<compgen>}
                                                {<-W>}
                                                {(SQ <'force= list='>)}
                                                {<-->}
                                                {(DQ ($ Id.VSub_DollarName cur))}
                                              ]
                                              redirects: []
                                              do_fork: T
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      }
                                    ]
                                    right: <Id.Right_ShArrayLiteral _>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-noconfig>
                      pattern: (pat.Words words:[{<-noconfig>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'COMPREPLY='>
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  name: COMPREPLY
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (ShArrayLiteral
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Simple
                                              blame_tok: <compgen>
                                              more_env: []
                                              words: [
                                                {<compgen>}
                                                {<-W>}
                                                {(SQ <'all gui system user'>)}
                                                {<-->}
                                                {(DQ ($ Id.VSub_DollarName cur))}
                                              ]
                                              redirects: []
                                              do_fork: T
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      }
                                    ]
                                    right: <Id.Right_ShArrayLiteral _>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <->
                      pattern: (pat.Words words:[{<-> <Id.Lit_Star '*'>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.AndOr
                          children: [
                            (command.Pipeline
                              children: [
                                (command.Simple
                                  blame_tok: <Id.VSub_DollarName '$cmd'>
                                  more_env: []
                                  words: [
                                    {($ Id.VSub_DollarName cmd)}
                                    {<-nomsgcolor>}
                                    {<-nomsgmodule>}
                                    {<-list-options>}
                                  ]
                                  redirects: [
                                    (Redir
                                      op: <Id.Redir_Great '2>'>
                                      loc: (redir_loc.Fd fd:2)
                                      arg: {<'/dev/null'>}
                                    )
                                  ]
                                  do_fork: T
                                )
                                (command.WhileUntil
                                  keyword: <Id.KW_While while>
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.Simple
                                              blame_tok: <read>
                                              more_env: []
                                              words: [{<read>} {<-r>} {<i>} {<j>} {<k>}]
                                              redirects: []
                                              do_fork: T
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  body: 
                                    (command.DoGroup
                                      left: <Id.KW_Do do>
                                      children: [
                                        (command.If
                                          if_kw: <Id.KW_If if>
                                          arms: [
                                            (IfArm
                                              keyword: <Id.KW_If if>
                                              cond: 
                                                (condition.Shell
                                                  commands: [
                                                    (command.Sentence
                                                      child: 
                                                        (command.DBracket
                                                          left: <Id.KW_DLeftBracket '[['>
                                                          expr: 
                                                            (bool_expr.Binary
                                                              op_id: Id.BoolBinary_GlobDEqual
                                                              left: {($ Id.VSub_DollarName i)}
                                                              right: 
                                                                {
                                                                  (BracedVarSub
                                                                    left: <Id.Left_DollarBrace '${'>
                                                                    token: <Id.VSub_Name prev>
                                                                    var_name: prev
                                                                    suffix_op: 
                                                                      (suffix_op.Unary
                                                                        op: <Id.VOp1_Pound '#'>
                                                                        arg_word: {<->}
                                                                      )
                                                                    right: <Id.Right_DollarBrace '}'>
                                                                  )
                                                                }
                                                            )
                                                          right: <Id.Lit_DRightBracket ']]'>
                                                          redirects: []
                                                        )
                                                      terminator: <Id.Op_Semi _>
                                                    )
                                                  ]
                                                )
                                              then_kw: <Id.KW_Then then>
                                              action: [
                                                (command.AndOr
                                                  children: [
                                                    (command.DBracket
                                                      left: <Id.KW_DLeftBracket '[['>
                                                      expr: 
                                                        (bool_expr.Binary
                                                          op_id: Id.BoolBinary_GlobNEqual
                                                          left: 
                                                            {
                                                              (BracedVarSub
                                                                left: <Id.Left_DollarBrace '${'>
                                                                token: <Id.VSub_Name j>
                                                                var_name: j
                                                                suffix_op: 
                                                                  (suffix_op.Unary
                                                                    op: <Id.VOp1_DComma ',,'>
                                                                    arg_word: {}
                                                                  )
                                                                right: <Id.Right_DollarBrace '}'>
                                                              )
                                                            }
                                                          right: 
                                                            {
                                                              (word_part.ExtGlob
                                                                op: <Id.ExtGlob_At '@('>
                                                                arms: [{<flag>} {<print>}]
                                                                right: <Id.Right_ExtGlob _>
                                                              )
                                                            }
                                                        )
                                                      right: <Id.Lit_DRightBracket ']]'>
                                                      redirects: []
                                                    )
                                                    (command.ControlFlow
                                                      keyword: <Id.ControlFlow_Return return>
                                                      arg_word: {<1>}
                                                    )
                                                  ]
                                                  ops: [<Id.Op_DAmp _>]
                                                )
                                                (command.ControlFlow
                                                  keyword: <Id.ControlFlow_Break break>
                                                )
                                              ]
                                              spids: [2041 2058]
                                            )
                                          ]
                                          else_action: []
                                          fi_kw: <Id.KW_Fi fi>
                                          redirects: []
                                        )
                                      ]
                                      right: <Id.KW_Done done>
                                    )
                                  redirects: []
                                )
                              ]
                              ops: [<Id.Op_Pipe _>]
                            )
                            (command.ControlFlow
                              keyword: <Id.ControlFlow_Return return>
                              arg_word: {<0>}
                            )
                          ]
                          ops: [<Id.Op_DPipe _>]
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                  ]
                  arms_end: <Id.KW_Esac esac>
                  redirects: []
                )
                (command.Case
                  case_kw: <Id.KW_Case case>
                  to_match: (case_arg.Word w:{($ Id.VSub_DollarName cur)})
                  arms_start: <Id.KW_In in>
                  arms: [
                    (CaseArm
                      left: <->
                      pattern: (pat.Words words:[{<-> <Id.Lit_Star '*'>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'COMPREPLY='>
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  name: COMPREPLY
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (ShArrayLiteral
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Simple
                                              blame_tok: <compgen>
                                              more_env: []
                                              words: [
                                                {<compgen>}
                                                {<-W>}
                                                {
                                                  (SQ 
                                                    <
'$( $cmd -nomsgcolor -nomsgmodule -list-options 2>/dev/null | \\\n'
                                                    > <'                sed -ne '>
                                                  ) <1> <Id.Lit_Comma ','> <'/'> <Id.Lit_Other '^'> <Id.KW_DLeftBracket '[['> <Id.Lit_Colon ':'> <space> 
                                                  <Id.Lit_Colon ':'> <Id.Lit_RBracket ']'> <Id.Lit_RBracket ']'> <Id.Lit_Star '*'> <'Name/d'> 
                                                  (SQ <' \\\n'> 
                                                    <
'                    -e "s/^[[:space:]]*/-/" -e "s/[[:space:]:].*//" \\\n'
                                                    > <'                    -e "/^-\\(Total\\|.*\\*\\)\\{0,1\\}$/!p" )'>
                                                  )
                                                }
                                                {<-->}
                                                {(DQ ($ Id.VSub_DollarName cur))}
                                              ]
                                              redirects: []
                                              do_fork: T
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      }
                                    ]
                                    right: <Id.Right_ShArrayLiteral _>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <Id.Lit_Star '*'>
                      pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.Simple
                          blame_tok: <_filedir>
                          more_env: []
                          words: [
                            {<_filedir>}
                            {
                              (SQ 
                                <
'@(mp?(e)g|MP?(E)G|wm[av]|WM[AV]|avi|AVI|asf|ASF|vob|VOB|bin|BIN|dat|DAT|vcd|VCD|ps|PS|pes|PES|fl[iv]|FL[IV]|fxm|FXM|viv|VIV|rm?(j)|RM?(J)|ra?(m)|RA?(M)|yuv|YUV|mov|MOV|qt|QT|mp[234]|MP[234]|m4[av]|M4[AV]|og[gmavx]|OG[GMAVX]|w?(a)v|W?(A)V|dump|DUMP|mk[av]|MK[AV]|m4a|M4A|aac|AAC|m[24]v|M[24]V|dv|DV|rmvb|RMVB|mid|MID|t[ps]|T[PS]|3g[p2]|3gpp?(2)|mpc|MPC|flac|FLAC|vro|VRO|divx|DIVX|aif?(f)|AIF?(F)|m2t?(s)|M2T?(S)|mts|MTS|vdr|VDR|xvid|XVID|ape|APE|gif|GIF|nut|NUT|bik|BIK|webm|WEBM|amr|AMR|awb|AWB|iso|ISO|opus|OPUS)?(.part)'
                                >
                              )
                            }
                          ]
                          redirects: []
                          do_fork: T
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                  ]
                  arms_end: <Id.KW_Esac esac>
                  redirects: []
                )
                (command.ControlFlow
                  keyword: <Id.ControlFlow_Return return>
                  arg_word: {<0>}
                )
              ]
              redirects: []
              right: <Id.Lit_RBrace '}'>
            )
        )
        (command.Simple
          blame_tok: <complete>
          more_env: []
          words: [
            {<complete>}
            {<-F>}
            {<_mplayer>}
            {<mplayer>}
            {<mplayer2>}
            {<mencoder>}
            {<gmplayer>}
            {<kplayer>}
          ]
          redirects: []
          do_fork: T
        )
      ]
      ops: [<Id.Op_DAmp _>]
    )
  ]
)