(command.CommandList
  children: [
    (command.FuncDef
      name: _mplayer_options_list
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:cur spids:[11])
                  op: Equal
                  rhs: 
                    {
                      (word_part.BracedVarSub
                        token: <VSub_Name cur>
                        suffix_op: 
                          (suffix_op.StringUnary
                            op_id: VOp1_Percent
                            arg_word: {(word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\\\'>)}
                          )
                        spids: [12 16]
                      )
                    }
                  spids: [11]
                )
              ]
              spids: [11]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:COMPREPLY spids:[19])
                  op: Equal
                  rhs: 
                    {
                      (word_part.ArrayLiteralPart
                        words: [
                          {
                            (word_part.CommandSubPart
                              command_list: 
                                (command.CommandList
                                  children: [
                                    (C {(compgen)} {(-W)} 
                                      {
                                        (DQ 
                                          (word_part.CommandSubPart
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (command.Pipeline
                                                    children: [
                                                      (command.SimpleCommand
                                                        words: [
                                                          {($ VSub_Number '$1')}
                                                          {(-nomsgcolor)}
                                                          {(-nomsgmodule)}
                                                          {($ VSub_Number '$2')}
                                                          {(help)}
                                                        ]
                                                        redirects: [
                                                          (redir.Redir
                                                            op: <Redir_Great '2>'>
                                                            fd: 2
                                                            arg_word: {(/dev/null)}
                                                          )
                                                        ]
                                                      )
                                                      (C {(sed)} {(-e)} {(SQ <'/^Available/,/^$/!d'>)} 
                                                        {(-e)} {(SQ <'/^Available/d'>)}
                                                      )
                                                      (C {(awk)} {(SQ <'{print $1}'>)})
                                                      (C {(sed)} {(-e)} {(SQ <'s/:$//'>)} {(-e)} 
                                                        {(SQ <'s/^'>) 
                                                          (word_part.BracedVarSub
                                                            token: <VSub_Number 2>
                                                            suffix_op: 
                                                              (suffix_op.StringUnary
                                                                op_id: VOp1_Pound
                                                                arg_word: {(-)}
                                                              )
                                                            spids: [87 91]
                                                          ) (SQ <'$//'>)
                                                        } {(-e)} {(SQ <'s/<.*//'>)}
                                                      )
                                                    ]
                                                    negated: F
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub '$('>
                                            spids: [29 102]
                                          )
                                        )
                                      } {(--)} {(DQ ($ VSub_DollarName '$cur'))}
                                    )
                                  ]
                                )
                              left_token: <Left_CommandSub '$('>
                              spids: [22 111]
                            )
                          }
                        ]
                      )
                    }
                  spids: [19]
                )
              ]
              spids: [19]
            )
          ]
          spids: [8]
        )
      spids: [4 7]
    )
    (command.AndOr
      ops: [Op_DAmp]
      children: [
        (command.FuncDef
          name: _mplayer
          body: 
            (command.BraceGroup
              children: [
                (command.Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:cur spids:[127])
                      op: Equal
                      spids: [127]
                    )
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:prev spids:[129])
                      op: Equal
                      spids: [129]
                    )
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:words spids:[131])
                      op: Equal
                      spids: [131]
                    )
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:cword spids:[133])
                      op: Equal
                      spids: [133]
                    )
                  ]
                  spids: [125]
                )
                (command.AndOr
                  ops: [Op_DPipe]
                  children: [
                    (C {(_init_completion)} {(-n)} {(Lit_Other ':')})
                    (command.ControlFlow token:<ControlFlow_Return return>)
                  ]
                )
                (command.Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:cmd spids:[150])
                      op: Equal
                      rhs: 
                        {
                          (word_part.BracedVarSub
                            token: <VSub_Name words>
                            bracket_op: 
                              (bracket_op.ArrayIndex
                                expr: (arith_expr.ArithWord w:{(Lit_Digits 0)})
                              )
                            spids: [151 156]
                          )
                        }
                      spids: [150]
                    )
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:i spids:[158])
                      op: Equal
                      spids: [158]
                    )
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:j spids:[160])
                      op: Equal
                      spids: [160]
                    )
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:k spids:[162])
                      op: Equal
                      rhs: {(0)}
                      spids: [162]
                    )
                  ]
                  spids: [148]
                )
                (command.Case
                  to_match: {($ VSub_DollarName '$prev')}
                  arms: [
                    (case_arm
                      pat_list: [
                        {(-) (Lit_Other '[') (av) (Lit_Other ']') (Lit_Other '[') (cfo) (Lit_Other ']')}
                        {(-) (Lit_Other '[') (av) (Lit_Other ']') (fm)}
                        {(-vop)}
                        {(-fstype)}
                        {(-demuxer)}
                        {(-o) (Lit_Other '[') (av) (Lit_Other ']') (c)}
                        {(-of)}
                        {(-profile)}
                        {(-audio-demuxer)}
                        {(-sub-demuxer)}
                      ]
                      action: [
                        (C {(_mplayer_options_list)} {($ VSub_DollarName '$cmd')} 
                          {($ VSub_DollarName '$prev')}
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [174 210 225 16777215]
                    )
                    (case_arm
                      pat_list: [{(-show-profile)}]
                      action: [
                        (C {(_mplayer_options_list)} {($ VSub_DollarName '$cmd')} {(-profile)})
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [228 229 244 16777215]
                    )
                    (case_arm
                      pat_list: [{(-audiofile)} {(-audio-file)}]
                      action: [
                        (C {(_filedir)} {(SQ <'@(mp3|mpg|ogg|w?(a)v|mid|flac|mka|ac3|ape)'>)})
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [247 250 265 16777215]
                    )
                    (case_arm
                      pat_list: [{(-font)} {(-subfont)}]
                      action: [
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.BoolBinary
                                          op_id: BoolBinary_GlobDEqual
                                          left: {($ VSub_DollarName '$prev')}
                                          right: {(-font)}
                                        )
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [(C {(_filedir)} {(SQ <'@(desc|ttf)'>)})]
                              spids: [16777215 287]
                            )
                          ]
                          else_action: [(C {(_filedir)} {(ttf)})]
                          spids: [297 305]
                        )
                        (command.Assignment
                          keyword: Assign_Local
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:IFS spids:[310])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.SingleQuotedPart
                                    left: <Left_DollarSingleQuote "$'">
                                    tokens: [<Char_OneChar '\\n'>]
                                    spids: [311 313]
                                  )
                                }
                              spids: [310]
                            )
                          ]
                          spids: [308]
                        )
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:COMPREPLY spids:[316])
                              op: PlusEqual
                              rhs: 
                                {
                                  (word_part.ArrayLiteralPart
                                    words: [
                                      {
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} {(SQ <'$( fc-list 2>/dev/null )'>)} 
                                                  {(--)} {(DQ ($ VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [319 335]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [316]
                            )
                          ]
                          spids: [316]
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [268 271 345 16777215]
                    )
                    (case_arm
                      pat_list: [{(-sub)} {(-sub-file)}]
                      action: [
                        (C {(_filedir)} {(SQ <'@(srt|sub|txt|utf|rar|mpsub|smi|js|ssa|ass)'>)})
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [348 351 366 16777215]
                    )
                    (case_arm
                      pat_list: [{(-vobsub)}]
                      action: [
                        (C {(_filedir)} {(SQ <'@(idx|ifo|sub)'>)})
                        (command.Assignment
                          keyword: Assign_Local
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:IFS spids:[382])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.SingleQuotedPart
                                    left: <Left_DollarSingleQuote "$'">
                                    tokens: [<Char_OneChar '\\n'>]
                                    spids: [383 385]
                                  )
                                }
                              spids: [382]
                            )
                          ]
                          spids: [380]
                        )
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:COMPREPLY spids:[388])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.ArrayLiteralPart
                                    words: [
                                      {
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (command.ForEach
                                                  iter_name: i
                                                  iter_words: [
                                                    {
                                                      (DQ 
                                                        (word_part.BracedVarSub
                                                          token: <VSub_Name COMPREPLY>
                                                          bracket_op: 
                                                            (bracket_op.WholeArray
                                                              op_id: Lit_At
                                                            )
                                                          spids: [400 405]
                                                        )
                                                      )
                                                    }
                                                  ]
                                                  do_arg_iter: F
                                                  body: 
                                                    (command.DoGroup
                                                      children: [
                                                        (command.If
                                                          arms: [
                                                            (if_arm
                                                              cond: [
                                                                (command.Sentence
                                                                  child: 
                                                                    (command.DBracket
                                                                      expr: 
                                                                        (bool_expr.LogicalAnd
                                                                          left: 
                                                                            (bool_expr.BoolUnary
                                                                              op_id: BoolUnary_f
                                                                              child: 
                                                                                {
                                                                                  ($ VSub_DollarName 
'$i'
                                                                                  )
                                                                                }
                                                                            )
                                                                          right: 
                                                                            (bool_expr.BoolUnary
                                                                              op_id: BoolUnary_r
                                                                              child: 
                                                                                {
                                                                                  ($ VSub_DollarName 
'$i'
                                                                                  )
                                                                                }
                                                                            )
                                                                        )
                                                                    )
                                                                  terminator: <Op_Semi ';'>
                                                                )
                                                              ]
                                                              action: [
                                                                (C {(printf)} {(SQ <'%s\\n'>)} 
                                                                  {
                                                                    (word_part.BracedVarSub
                                                                      token: <VSub_Name i>
                                                                      suffix_op: 
                                                                        (suffix_op.StringUnary
                                                                          op_id: VOp1_Percent
                                                                          arg_word: {('.*')}
                                                                        )
                                                                      spids: [438 442]
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                              spids: [16777215 429]
                                                            )
                                                          ]
                                                          else_action: [
                                                            (C {(printf)} {(SQ <'%s\\n'>)} 
                                                              {($ VSub_DollarName '$i')}
                                                            )
                                                          ]
                                                          spids: [445 457]
                                                        )
                                                      ]
                                                      spids: [409 460]
                                                    )
                                                  spids: [398 407]
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [391 462]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [388]
                            )
                          ]
                          spids: [388]
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [369 370 472 16777215]
                    )
                    (case_arm
                      pat_list: [{(-subcp)} {(-msgcharset)}]
                      action: [
                        (command.Assignment
                          keyword: Assign_Local
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:cp spids:[483])
                              op: Equal
                              spids: [483]
                            )
                          ]
                          spids: [481]
                        )
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:cp spids:[486])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.ArrayLiteralPart
                                    words: [
                                      {
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (command.Pipeline
                                                  children: [
                                                    (command.SimpleCommand
                                                      words: [{(iconv)} {(--list)}]
                                                      redirects: [
                                                        (redir.Redir
                                                          op: <Redir_Great '2>'>
                                                          fd: 2
                                                          arg_word: {(/dev/null)}
                                                        )
                                                      ]
                                                    )
                                                    (command.SimpleCommand
                                                      words: [{(sed)} {(-e)} {(DQ ('s@//@@;'))}]
                                                      redirects: [
                                                        (redir.Redir
                                                          op: <Redir_Great '2>'>
                                                          fd: 2
                                                          arg_word: {(/dev/null)}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                  negated: F
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [489 511]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [486]
                            )
                          ]
                          spids: [486]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.BoolBinary
                                          op_id: BoolBinary_GlobDEqual
                                          left: {(DQ ($ VSub_DollarName '$cur'))}
                                          right: 
                                            {
                                              (DQ 
                                                (word_part.BracedVarSub
                                                  token: <VSub_Name cur>
                                                  suffix_op: 
                                                    (suffix_op.StringUnary
                                                      op_id: VOp1_DComma
                                                      arg_word: (word.EmptyWord)
                                                    )
                                                  spids: [527 530]
                                                )
                                              )
                                            }
                                        )
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:COMPREPLY spids:[539])
                                      op: Equal
                                      rhs: 
                                        {
                                          (word_part.ArrayLiteralPart
                                            words: [
                                              {
                                                (word_part.CommandSubPart
                                                  command_list: 
                                                    (command.CommandList
                                                      children: [
                                                        (C {(compgen)} {(-W)} {(SQ <'${cp[@],,}'>)} 
                                                          {(--)} {(DQ ($ VSub_DollarName '$cur'))}
                                                        )
                                                      ]
                                                    )
                                                  left_token: <Left_CommandSub '$('>
                                                  spids: [542 558]
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [539]
                                    )
                                  ]
                                  spids: [539]
                                )
                              ]
                              spids: [16777215 536]
                            )
                          ]
                          else_action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:COMPREPLY spids:[566])
                                  op: Equal
                                  rhs: 
                                    {
                                      (word_part.ArrayLiteralPart
                                        words: [
                                          {
                                            (word_part.CommandSubPart
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {(compgen)} {(-W)} {(SQ <'${cp[@]^^}'>)} {(--)} 
                                                      {(DQ ($ VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub '$('>
                                              spids: [569 585]
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [566]
                                )
                              ]
                              spids: [566]
                            )
                          ]
                          spids: [563 590]
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [475 478 598 16777215]
                    )
                    (case_arm
                      pat_list: [{(-ifo)}]
                      action: [
                        (C {(_filedir)} {(ifo)})
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [601 602 615 16777215]
                    )
                    (case_arm
                      pat_list: [{(-cuefile)}]
                      action: [
                        (C {(_filedir)} {(SQ <'@(bin|cue)'>)})
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [618 619 634 16777215]
                    )
                    (case_arm
                      pat_list: [{(-skin)}]
                      action: [
                        (command.Assignment
                          keyword: Assign_Local
                          flags: [-a]
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:dirs spids:[653])
                              op: Equal
                              spids: [653]
                            )
                          ]
                          spids: [649]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.BoolUnary
                                          op_id: BoolUnary_n
                                          child: {($ VSub_DollarName '$MPLAYER_SKINS_DIR')}
                                        )
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:dirs spids:[670])
                                      op: Equal
                                      rhs: 
                                        {
                                          (word_part.ArrayLiteralPart
                                            words: [{($ VSub_DollarName '$MPLAYER_SKINS_DIR')}]
                                          )
                                        }
                                      spids: [670]
                                    )
                                  ]
                                  spids: [670]
                                )
                              ]
                              spids: [16777215 667]
                            )
                          ]
                          else_action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:dirs spids:[679])
                                  op: Equal
                                  rhs: 
                                    {
                                      (word_part.ArrayLiteralPart
                                        words: [
                                          {(/usr/share/mplayer/skins)}
                                          {(/usr/local/share/mplayer/skins)}
                                        ]
                                      )
                                    }
                                  spids: [679]
                                )
                              ]
                              spids: [679]
                            )
                          ]
                          spids: [676 687]
                        )
                        (command.Assignment
                          keyword: Assign_Local
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:IFS spids:[693])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.SingleQuotedPart
                                    left: <Left_DollarSingleQuote "$'">
                                    tokens: [<Char_OneChar '\\n'>]
                                    spids: [694 696]
                                  )
                                }
                              spids: [693]
                            )
                          ]
                          spids: [691]
                        )
                        (command.ForEach
                          iter_name: i
                          iter_words: [
                            {(word_part.TildeSubPart token:<Lit_TildeLike '~'>) (/.mplayer/skins)}
                            {
                              (word_part.BracedVarSub
                                token: <VSub_Name dirs>
                                bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                                spids: [708 713]
                              )
                            }
                          ]
                          do_arg_iter: F
                          body: 
                            (command.DoGroup
                              children: [
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (command.Sentence
                                          child: 
                                            (command.DBracket
                                              expr: 
                                                (bool_expr.LogicalAnd
                                                  left: 
                                                    (bool_expr.BoolUnary
                                                      op_id: BoolUnary_d
                                                      child: {($ VSub_DollarName '$i')}
                                                    )
                                                  right: 
                                                    (bool_expr.BoolUnary
                                                      op_id: BoolUnary_r
                                                      child: {($ VSub_DollarName '$i')}
                                                    )
                                                )
                                            )
                                          terminator: <Op_Semi ';'>
                                        )
                                      ]
                                      action: [
                                        (command.ForEach
                                          iter_name: j
                                          iter_words: [
                                            {
                                              (word_part.CommandSubPart
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (C {(compgen)} {(-d)} {(--)} 
                                                        {($ VSub_DollarName '$i') (/) 
                                                          ($ VSub_DollarName '$cur')
                                                        }
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_CommandSub '$('>
                                                spids: [745 757]
                                              )
                                            }
                                          ]
                                          do_arg_iter: F
                                          body: 
                                            (command.DoGroup
                                              children: [
                                                (command.Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: 
                                                        (lhs_expr.LhsIndexedName
                                                          name: COMPREPLY
                                                          index: 
                                                            (arith_expr.ArithWord
                                                              w: {($ VSub_DollarName '$k')}
                                                            )
                                                          spids: [763]
                                                        )
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (word_part.BracedVarSub
                                                            token: <VSub_Name j>
                                                            suffix_op: 
                                                              (suffix_op.StringUnary
                                                                op_id: VOp1_Pound
                                                                arg_word: 
                                                                  {($ VSub_DollarName '$i') 
                                                                    (Lit_Slash /)
                                                                  }
                                                              )
                                                            spids: [766 771]
                                                          )
                                                        }
                                                      spids: [763]
                                                    )
                                                  ]
                                                  spids: [763]
                                                )
                                                (command.Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (lhs_expr.LhsName name:k spids:[774])
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (word_part.ArithSubPart
                                                            anode: 
                                                              (arith_expr.UnaryAssign
                                                                op_id: Arith_DPlus
                                                                child: 
                                                                  (lhs_expr.LhsName
                                                                    name: k
                                                                    spids: [777]
                                                                  )
                                                              )
                                                            spids: [775 779]
                                                          )
                                                        }
                                                      spids: [774]
                                                    )
                                                  ]
                                                  spids: [774]
                                                )
                                              ]
                                              spids: [760 782]
                                            )
                                          spids: [744 758]
                                        )
                                      ]
                                      spids: [16777215 736]
                                    )
                                  ]
                                  spids: [16777215 785]
                                )
                              ]
                              spids: [716 788]
                            )
                          spids: [704 714]
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [637 638 796 16777215]
                    )
                    (case_arm
                      pat_list: [{(-cdrom-device)}]
                      action: [
                        (C {(_cd_devices)})
                        (C {(_dvd_devices)})
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [799 800 814 16777215]
                    )
                    (case_arm
                      pat_list: [{(-dvd-device)}]
                      action: [
                        (C {(_dvd_devices)})
                        (C {(_filedir)} {(iso)})
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [817 818 834 16777215]
                    )
                    (case_arm
                      pat_list: [{(-bluray-device)}]
                      action: [
                        (C {(_filedir)} {(-d)})
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [837 838 851 16777215]
                    )
                    (case_arm
                      pat_list: [{(-mixer)} {(-dvdauth)} {(-fb)} {(-zrdev)}]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:cur spids:[864])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.BracedVarSub
                                    token: <VSub_Name cur>
                                    suffix_op: 
                                      (suffix_op.StringUnary
                                        op_id: VTest_ColonEquals
                                        arg_word: {(Lit_Slash /) (dev) (Lit_Slash /)}
                                      )
                                    spids: [865 871]
                                  )
                                }
                              spids: [864]
                            )
                          ]
                          spids: [864]
                        )
                        (C {(_filedir)})
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [854 861 882 16777215]
                    )
                    (case_arm
                      pat_list: [
                        {(-edl)}
                        {(-edlout)}
                        {(-lircconf)}
                        {(-menu-cfg)}
                        {(-playlist)}
                        {(-csslib)}
                        {(-dumpfile)}
                        {(-subfile)}
                        {(-vobsub)}
                        {(-aofile)}
                        {(-fbmodeconfig)}
                        {(-include)}
                        {(-o)}
                        {(-dvdkey)}
                        {(-passlogfile)}
                      ]
                      action: [
                        (C {(_filedir)})
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [885 920 931 16777215]
                    )
                    (case_arm
                      pat_list: [
                        {(-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) (Lit_Other '[') (wh) (Lit_Other ']')}
                        {(-wid)}
                        {(-monitor-dotclock)}
                        {(-monitor-) (Lit_Other '[') (hv) (Lit_Other ']') (freq)}
                        {(-panscan)}
                        {(-saturation)}
                        {(-xineramascreen)}
                        {(-zrcrop)}
                        {(-zrnorm)}
                        {(-zrquality)}
                        {(-zr) (Lit_Other '[') (xy) (Lit_Other ']') (doff)}
                        {(-zr) (Lit_Other '[') (vh) (Lit_Other ']') (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)}
                      ]
                      action: [(command.ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})]
                      spids: [934 1177 1185 16777215]
                    )
                    (case_arm
                      pat_list: [{(-channels)}]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:COMPREPLY spids:[1192])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.ArrayLiteralPart
                                    words: [
                                      {
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} {(SQ <'2 4 6 8'>)} {(--)} 
                                                  {(DQ ($ VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [1195 1211]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1192]
                            )
                          ]
                          spids: [1192]
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [1188 1189 1221 16777215]
                    )
                    (case_arm
                      pat_list: [{(-aspect)} {(-monitoraspect)}]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:COMPREPLY spids:[1230])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.ArrayLiteralPart
                                    words: [
                                      {
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {
                                                    (SQ <'1:1 3:2 4:3 5:4 14:9 14:10 16:9 16:10\n'> 
                                                      <'                2.35:1'>
                                                    )
                                                  } {(--)} {(DQ ($ VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [1233 1250]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1230]
                            )
                          ]
                          spids: [1230]
                        )
                        (C {(__ltrim_colon_completions)} {(DQ ($ VSub_DollarName '$cur'))})
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [1224 1227 1267 16777215]
                    )
                    (case_arm
                      pat_list: [{(-lavdopts)}]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:COMPREPLY spids:[1274])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.ArrayLiteralPart
                                    words: [
                                      {
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {
                                                    (SQ <'bitexact bug= debug= ec= er= fast gray\n'> 
                                                      <
'                idct= lowres= sb= st= skiploopfilter= skipidct= skipframe=\n'
                                                      > <'                threads= vismv= vstats'>
                                                    )
                                                  } {(--)} {(DQ ($ VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [1277 1295]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1274]
                            )
                          ]
                          spids: [1274]
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [1270 1271 1305 16777215]
                    )
                    (case_arm
                      pat_list: [{(-lavcopts)}]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:COMPREPLY spids:[1312])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.ArrayLiteralPart
                                    words: [
                                      {
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(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 ($ VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [1315 1340]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1312]
                            )
                          ]
                          spids: [1312]
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [1308 1309 1350 16777215]
                    )
                    (case_arm
                      pat_list: [{(-ssf)}]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:COMPREPLY spids:[1357])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.ArrayLiteralPart
                                    words: [
                                      {
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {(SQ <'lgb= cgb= ls= cs= chs= cvs='>)} {(--)} {(DQ ($ VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [1360 1378]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1357]
                            )
                          ]
                          spids: [1357]
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [1353 1354 1388 16777215]
                    )
                    (case_arm
                      pat_list: [{(-jpeg)}]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:COMPREPLY spids:[1395])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.ArrayLiteralPart
                                    words: [
                                      {
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {
                                                    (SQ <'noprogressive progressive nobaseline\n'> 
                                                      <
'                baseline optimize= smooth= quality= outdir='
                                                      >
                                                    )
                                                  } {(--)} {(DQ ($ VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [1398 1415]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1395]
                            )
                          ]
                          spids: [1395]
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [1391 1392 1425 16777215]
                    )
                    (case_arm
                      pat_list: [{(-xvidopts)}]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:COMPREPLY spids:[1432])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.ArrayLiteralPart
                                    words: [
                                      {
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} {(SQ <'dr2 nodr2'>)} {(--)} 
                                                  {(DQ ($ VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [1435 1451]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1432]
                            )
                          ]
                          spids: [1432]
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [1428 1429 1461 16777215]
                    )
                    (case_arm
                      pat_list: [{(-xvidencopts)}]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:COMPREPLY spids:[1468])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.ArrayLiteralPart
                                    words: [
                                      {
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(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 ($ VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [1471 1491]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1468]
                            )
                          ]
                          spids: [1468]
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [1464 1465 1501 16777215]
                    )
                    (case_arm
                      pat_list: [{(-divx4opts)}]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:COMPREPLY spids:[1508])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.ArrayLiteralPart
                                    words: [
                                      {
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(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 ($ VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [1511 1529]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1508]
                            )
                          ]
                          spids: [1508]
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [1504 1505 1539 16777215]
                    )
                    (case_arm
                      pat_list: [{(-info)}]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:COMPREPLY spids:[1546])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.ArrayLiteralPart
                                    words: [
                                      {
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {
                                                    (SQ <'name= artist= genre= subject=\n'> 
                                                      <
'                copyright= srcform= comment= help'
                                                      >
                                                    )
                                                  } {(--)} {(DQ ($ VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [1549 1566]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1546]
                            )
                          ]
                          spids: [1546]
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [1542 1543 1576 16777215]
                    )
                    (case_arm
                      pat_list: [{(-lameopts)}]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:COMPREPLY spids:[1583])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.ArrayLiteralPart
                                    words: [
                                      {
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {
                                                    (SQ <'vbr= abr cbr br= q= aq= ratio= vol=\n'> 
                                                      <
'                mode= padding= fast preset= help'
                                                      >
                                                    )
                                                  } {(--)} {(DQ ($ VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [1586 1603]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1583]
                            )
                          ]
                          spids: [1583]
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [1579 1580 1613 16777215]
                    )
                    (case_arm
                      pat_list: [{(-rawaudio)}]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:COMPREPLY spids:[1620])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.ArrayLiteralPart
                                    words: [
                                      {
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {(SQ <'on channels= rate= samplesize= format='>)} {(--)} {(DQ ($ VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [1623 1641]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1620]
                            )
                          ]
                          spids: [1620]
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [1616 1617 1651 16777215]
                    )
                    (case_arm
                      pat_list: [{(-rawvideo)}]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:COMPREPLY spids:[1658])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.ArrayLiteralPart
                                    words: [
                                      {
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {
                                                    (SQ <'on fps= sqcif qcif cif 4cif pal ntsc w=\n'> 
                                                      <
'                h= y420 yv12 yuy2 y8 format= size='
                                                      >
                                                    )
                                                  } {(--)} {(DQ ($ VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [1661 1678]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1658]
                            )
                          ]
                          spids: [1658]
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [1654 1655 1688 16777215]
                    )
                    (case_arm
                      pat_list: [{(-aop)}]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:COMPREPLY spids:[1695])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.ArrayLiteralPart
                                    words: [
                                      {
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {
                                                    (SQ <'list= delay= format= fout= volume= mul=\n'> 
                                                      <'                softclip'>
                                                    )
                                                  } {(--)} {(DQ ($ VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [1698 1715]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1695]
                            )
                          ]
                          spids: [1695]
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [1691 1692 1725 16777215]
                    )
                    (case_arm
                      pat_list: [{(-dxr2)}]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:COMPREPLY spids:[1732])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.ArrayLiteralPart
                                    words: [
                                      {
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(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 ($ VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [1735 1756]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1732]
                            )
                          ]
                          spids: [1732]
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [1728 1729 1766 16777215]
                    )
                    (case_arm
                      pat_list: [{(-tv)}]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:COMPREPLY spids:[1773])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.ArrayLiteralPart
                                    words: [
                                      {
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(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 ($ VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [1776 1797]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1773]
                            )
                          ]
                          spids: [1773]
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [1769 1770 1807 16777215]
                    )
                    (case_arm
                      pat_list: [{(-mf)}]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:COMPREPLY spids:[1814])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.ArrayLiteralPart
                                    words: [
                                      {
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} {(SQ <'on w= h= fps= type='>)} 
                                                  {(--)} {(DQ ($ VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [1817 1833]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1814]
                            )
                          ]
                          spids: [1814]
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [1810 1811 1843 16777215]
                    )
                    (case_arm
                      pat_list: [{(-cdda)}]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:COMPREPLY spids:[1850])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.ArrayLiteralPart
                                    words: [
                                      {
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {
                                                    (SQ <'speed= paranoia= generic-dev=\n'> 
                                                      <
'                sector-size= overlap= toc-bias toc-offset= skip noskip'
                                                      >
                                                    )
                                                  } {(--)} {(DQ ($ VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [1853 1872]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1850]
                            )
                          ]
                          spids: [1850]
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [1846 1847 1882 16777215]
                    )
                    (case_arm
                      pat_list: [{(-input)}]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:COMPREPLY spids:[1889])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.ArrayLiteralPart
                                    words: [
                                      {
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {
                                                    (SQ <'conf= ar-delay ar-rate keylist cmdlist\n'> 
                                                      <'                js-dev file'>
                                                    )
                                                  } {(--)} {(DQ ($ VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [1892 1909]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1889]
                            )
                          ]
                          spids: [1889]
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [1885 1886 1919 16777215]
                    )
                    (case_arm
                      pat_list: [{(-af-adv)}]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:COMPREPLY spids:[1926])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.ArrayLiteralPart
                                    words: [
                                      {
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} {(SQ <'force= list='>)} {(--)} 
                                                  {(DQ ($ VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [1929 1945]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1926]
                            )
                          ]
                          spids: [1926]
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [1922 1923 1955 16777215]
                    )
                    (case_arm
                      pat_list: [{(-noconfig)}]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:COMPREPLY spids:[1962])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.ArrayLiteralPart
                                    words: [
                                      {
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} {(SQ <'all gui system user'>)} 
                                                  {(--)} {(DQ ($ VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [1965 1981]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1962]
                            )
                          ]
                          spids: [1962]
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [1958 1959 1991 16777215]
                    )
                    (case_arm
                      pat_list: [{(-) (Lit_Other '*')}]
                      action: [
                        (command.AndOr
                          ops: [Op_DPipe]
                          children: [
                            (command.Pipeline
                              children: [
                                (command.SimpleCommand
                                  words: [
                                    {($ VSub_DollarName '$cmd')}
                                    {(-nomsgcolor)}
                                    {(-nomsgmodule)}
                                    {(-list-options)}
                                  ]
                                  redirects: [
                                    (redir.Redir
                                      op: <Redir_Great '2>'>
                                      fd: 2
                                      arg_word: {(/dev/null)}
                                    )
                                  ]
                                )
                                (command.WhileUntil
                                  keyword: <KW_While while>
                                  cond: [
                                    (command.Sentence
                                      child: (C {(read)} {(-r)} {(i)} {(j)} {(k)})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  body: 
                                    (command.DoGroup
                                      children: [
                                        (command.If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (command.Sentence
                                                  child: 
                                                    (command.DBracket
                                                      expr: 
                                                        (bool_expr.BoolBinary
                                                          op_id: BoolBinary_GlobDEqual
                                                          left: {($ VSub_DollarName '$i')}
                                                          right: 
                                                            {
                                                              (word_part.BracedVarSub
                                                                token: <VSub_Name prev>
                                                                suffix_op: 
                                                                  (suffix_op.StringUnary
                                                                    op_id: VOp1_Pound
                                                                    arg_word: {(-)}
                                                                  )
                                                                spids: [2046 2050]
                                                              )
                                                            }
                                                        )
                                                    )
                                                  terminator: <Op_Semi ';'>
                                                )
                                              ]
                                              action: [
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (command.DBracket
                                                      expr: 
                                                        (bool_expr.BoolBinary
                                                          op_id: BoolBinary_GlobNEqual
                                                          left: 
                                                            {
                                                              (word_part.BracedVarSub
                                                                token: <VSub_Name j>
                                                                suffix_op: 
                                                                  (suffix_op.StringUnary
                                                                    op_id: VOp1_DComma
                                                                    arg_word: {}
                                                                  )
                                                                spids: [2060 2063]
                                                              )
                                                            }
                                                          right: 
                                                            {
                                                              (word_part.ExtGlobPart
                                                                op: <ExtGlob_At '@('>
                                                                arms: [{(flag)} {(print)}]
                                                                spids: [2067 2071]
                                                              )
                                                            }
                                                        )
                                                    )
                                                    (command.ControlFlow
                                                      token: <ControlFlow_Return return>
                                                      arg_word: {(1)}
                                                    )
                                                  ]
                                                )
                                                (command.ControlFlow
                                                  token: <ControlFlow_Break break>
                                                )
                                              ]
                                              spids: [16777215 2055]
                                            )
                                          ]
                                          spids: [16777215 2085]
                                        )
                                      ]
                                      spids: [2035 2088]
                                    )
                                )
                              ]
                              negated: F
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(0)}
                            )
                          ]
                        )
                      ]
                      spids: [1994 1996 2097 16777215]
                    )
                  ]
                  spids: [167 171 2100]
                )
                (command.Case
                  to_match: {($ VSub_DollarName '$cur')}
                  arms: [
                    (case_arm
                      pat_list: [{(-) (Lit_Other '*')}]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:COMPREPLY spids:[2116])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.ArrayLiteralPart
                                    words: [
                                      {
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {
                                                    (SQ 
                                                      <
'$( $cmd -nomsgcolor -nomsgmodule -list-options 2>/dev/null | \\\n'
                                                      > <'                sed -ne '>
                                                    ) (1) (Lit_Comma ',') (/) (Lit_Other '^') (KW_DLeftBracket '[[') (Lit_Other ':') (space) (Lit_Other ':') 
                                                    (Lit_Other ']') (Lit_Other ']') (Lit_Other '*') (Name/d) 
                                                    (SQ <' \\\n'> 
                                                      <
'                    -e "s/^[[:space:]]*/-/" -e "s/[[:space:]:].*//" \\\n'
                                                      > <'                    -e "/^-\\(Total\\|.*\\*\\)\\{0,1\\}$/!p" )'>
                                                    )
                                                  } {(--)} {(DQ ($ VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [2119 2153]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [2116]
                            )
                          ]
                          spids: [2116]
                        )
                      ]
                      spids: [2111 2113 2158 16777215]
                    )
                    (case_arm
                      pat_list: [{(Lit_Other '*')}]
                      action: [
                        (C {(_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)'
                              >
                            )
                          }
                        )
                      ]
                      spids: [2161 2162 2172 16777215]
                    )
                  ]
                  spids: [2104 2108 2175]
                )
                (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
              ]
              spids: [122]
            )
          spids: [118 121]
        )
        (C {(complete)} {(-F)} {(_mplayer)} {(mplayer)} {(mplayer2)} {(mencoder)} {(gmplayer)} {(kplayer)})
      ]
    )
  ]
)