(command.CommandList
  children: [
    (command.ShFunction
      name: _mplayer_options_list
      body: 
        (command.BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:cur)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <Id.VSub_Name cur>
                        suffix_op: 
                          (suffix_op.Unary
                            op_id: Id.VOp1_Percent
                            arg_word: {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\\\'>)}
                          )
                      )
                    }
                  spids: [11]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (sh_array_literal
                        left: <Id.Op_LParen _>
                        words: [
                          {
                            (command_sub
                              left_token: <Id.Left_DollarParen '$('>
                              command_list: 
                                (command.CommandList
                                  children: [
                                    (C {<compgen>} {<-W>} 
                                      {
                                        (DQ 
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (command.Pipeline
                                                    children: [
                                                      (command.Simple
                                                        words: [
                                                          {($ Id.VSub_Number '$1')}
                                                          {<-nomsgcolor>}
                                                          {<-nomsgmodule>}
                                                          {($ Id.VSub_Number '$2')}
                                                          {<help>}
                                                        ]
                                                        redirects: [
                                                          (redir.Redir
                                                            op: <Id.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/^'>) 
                                                          (braced_var_sub
                                                            token: <Id.VSub_Number 2>
                                                            suffix_op: 
                                                              (suffix_op.Unary
                                                                op_id: Id.VOp1_Pound
                                                                arg_word: {<->}
                                                              )
                                                          ) (SQ <'$//'>)
                                                        } {<-e>} {(SQ <'s/<.*//'>)}
                                                      )
                                                    ]
                                                    negated: F
                                                  )
                                                ]
                                              )
                                          )
                                        )
                                      } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                    )
                                  ]
                                )
                            )
                          }
                        ]
                      )
                    }
                  spids: [19]
                )
              ]
            )
          ]
        )
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (command.ShFunction
          name: _mplayer
          body: 
            (command.BraceGroup
              children: [
                (C {<local>} {<cur>} {<prev>} {<words>} {<cword>})
                (command.AndOr
                  ops: [Id.Op_DPipe]
                  children: [
                    (C {<_init_completion>} {<-n>} {<Id.Lit_Other ':'>})
                    (command.ControlFlow token:<Id.ControlFlow_Return return>)
                  ]
                )
                (C {<local>} 
                  {<Id.Lit_VarLike 'cmd='> 
                    (braced_var_sub
                      token: <Id.VSub_Name words>
                      bracket_op: 
                        (bracket_op.ArrayIndex
                          expr: (arith_expr.ArithWord w:{<Id.Lit_Digits 0>})
                        )
                    )
                  } {<i>} {<j>} {<Id.Lit_VarLike 'k='> <0>}
                )
                (command.Case
                  to_match: {($ Id.VSub_DollarName '$prev')}
                  arms: [
                    (case_arm
                      pat_list: [
                        {<-> <Id.Lit_LBracket '['> <av> <Id.Lit_RBracket ']'> <Id.Lit_LBracket '['> <cfo> 
                          <Id.Lit_RBracket ']'>
                        }
                        {<-> <Id.Lit_LBracket '['> <av> <Id.Lit_RBracket ']'> <fm>}
                        {<-vop>}
                        {<-fstype>}
                        {<-demuxer>}
                        {<-o> <Id.Lit_LBracket '['> <av> <Id.Lit_RBracket ']'> <c>}
                        {<-of>}
                        {<-profile>}
                        {<-audio-demuxer>}
                        {<-sub-demuxer>}
                      ]
                      action: [
                        (C {<_mplayer_options_list>} {($ Id.VSub_DollarName '$cmd')} 
                          {($ Id.VSub_DollarName '$prev')}
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [174 210 225 -1]
                    )
                    (case_arm
                      pat_list: [{<-show-profile>}]
                      action: [
                        (C {<_mplayer_options_list>} {($ Id.VSub_DollarName '$cmd')} {<-profile>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [228 229 244 -1]
                    )
                    (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: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [247 250 265 -1]
                    )
                    (case_arm
                      pat_list: [{<-font>} {<-subfont>}]
                      action: [
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {($ Id.VSub_DollarName '$prev')}
                                          right: {<-font>}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                              action: [(C {<_filedir>} {(SQ <'@(desc|ttf)'>)})]
                              spids: [274 287]
                            )
                          ]
                          else_action: [(C {<_filedir>} {<ttf>})]
                        )
                        (C {<local>} 
                          {<Id.Lit_VarLike 'IFS='> 
                            (single_quoted
                              left: <Id.Left_SingleQuoteC "$'">
                              tokens: [<Id.Char_OneChar '\\n'>]
                            )
                          }
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.PlusEqual
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {<compgen>} {<-W>} {(SQ <'$( fc-list 2>/dev/null )'>)} 
                                                  {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [316]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [268 271 345 -1]
                    )
                    (case_arm
                      pat_list: [{<-sub>} {<-sub-file>}]
                      action: [
                        (C {<_filedir>} {(SQ <'@(srt|sub|txt|utf|rar|mpsub|smi|js|ssa|ass)'>)})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [348 351 366 -1]
                    )
                    (case_arm
                      pat_list: [{<-vobsub>}]
                      action: [
                        (C {<_filedir>} {(SQ <'@(idx|ifo|sub)'>)})
                        (C {<local>} 
                          {<Id.Lit_VarLike 'IFS='> 
                            (single_quoted
                              left: <Id.Left_SingleQuoteC "$'">
                              tokens: [<Id.Char_OneChar '\\n'>]
                            )
                          }
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (command.ForEach
                                                  iter_name: i
                                                  iter_words: [
                                                    {
                                                      (DQ 
                                                        (braced_var_sub
                                                          token: <Id.VSub_Name COMPREPLY>
                                                          bracket_op: 
                                                            (bracket_op.WholeArray
                                                              op_id: Id.Lit_At
                                                            )
                                                        )
                                                      )
                                                    }
                                                  ]
                                                  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.Unary
                                                                              op_id: Id.BoolUnary_f
                                                                              child: 
                                                                                {
                                                                                  ($ 
Id.VSub_DollarName '$i'
                                                                                  )
                                                                                }
                                                                            )
                                                                          right: 
                                                                            (bool_expr.Unary
                                                                              op_id: Id.BoolUnary_r
                                                                              child: 
                                                                                {
                                                                                  ($ 
Id.VSub_DollarName '$i'
                                                                                  )
                                                                                }
                                                                            )
                                                                        )
                                                                    )
                                                                  terminator: <Id.Op_Semi _>
                                                                )
                                                              ]
                                                              action: [
                                                                (C {<printf>} {(SQ <'%s\\n'>)} 
                                                                  {
                                                                    (braced_var_sub
                                                                      token: <Id.VSub_Name i>
                                                                      suffix_op: 
                                                                        (suffix_op.Unary
                                                                          op_id: Id.VOp1_Percent
                                                                          arg_word: {<'.*'>}
                                                                        )
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                              spids: [412 429]
                                                            )
                                                          ]
                                                          else_action: [
                                                            (C {<printf>} {(SQ <'%s\\n'>)} 
                                                              {($ Id.VSub_DollarName '$i')}
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [388]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [369 370 472 -1]
                    )
                    (case_arm
                      pat_list: [{<-subcp>} {<-msgcharset>}]
                      action: [
                        (C {<local>} {<cp>})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:cp)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (command.Pipeline
                                                  children: [
                                                    (command.Simple
                                                      words: [{<iconv>} {<--list>}]
                                                      redirects: [
                                                        (redir.Redir
                                                          op: <Id.Redir_Great '2>'>
                                                          fd: 2
                                                          arg_word: {</dev/null>}
                                                        )
                                                      ]
                                                    )
                                                    (command.Simple
                                                      words: [{<sed>} {<-e>} {(DQ <'s@//@@;'>)}]
                                                      redirects: [
                                                        (redir.Redir
                                                          op: <Id.Redir_Great '2>'>
                                                          fd: 2
                                                          arg_word: {</dev/null>}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                  negated: F
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [486]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                          right: 
                                            {
                                              (DQ 
                                                (braced_var_sub
                                                  token: <Id.VSub_Name cur>
                                                  suffix_op: (suffix_op.Unary op_id:Id.VOp1_DComma arg_word:(word.Empty))
                                                )
                                              )
                                            }
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (sh_array_literal
                                            left: <Id.Op_LParen _>
                                            words: [
                                              {
                                                (command_sub
                                                  left_token: <Id.Left_DollarParen '$('>
                                                  command_list: 
                                                    (command.CommandList
                                                      children: [
                                                        (C {<compgen>} {<-W>} {(SQ <'${cp[@],,}'>)} 
                                                          {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                        )
                                                      ]
                                                    )
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [539]
                                    )
                                  ]
                                )
                              ]
                              spids: [516 536]
                            )
                          ]
                          else_action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {<compgen>} {<-W>} {(SQ <'${cp[@]^^}'>)} {<-->} 
                                                      {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [566]
                                )
                              ]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [475 478 598 -1]
                    )
                    (case_arm
                      pat_list: [{<-ifo>}]
                      action: [
                        (C {<_filedir>} {<ifo>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [601 602 615 -1]
                    )
                    (case_arm
                      pat_list: [{<-cuefile>}]
                      action: [
                        (C {<_filedir>} {(SQ <'@(bin|cue)'>)})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [618 619 634 -1]
                    )
                    (case_arm
                      pat_list: [{<-skin>}]
                      action: [
                        (C {<local>} {<-a>} {<dirs>})
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_n
                                          child: {($ Id.VSub_DollarName '$MPLAYER_SKINS_DIR')}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:dirs)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (sh_array_literal
                                            left: <Id.Op_LParen _>
                                            words: [{($ Id.VSub_DollarName '$MPLAYER_SKINS_DIR')}]
                                          )
                                        }
                                      spids: [670]
                                    )
                                  ]
                                )
                              ]
                              spids: [656 667]
                            )
                          ]
                          else_action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:dirs)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {</usr/share/mplayer/skins>}
                                          {</usr/local/share/mplayer/skins>}
                                        ]
                                      )
                                    }
                                  spids: [679]
                                )
                              ]
                            )
                          ]
                        )
                        (C {<local>} 
                          {<Id.Lit_VarLike 'IFS='> 
                            (single_quoted
                              left: <Id.Left_SingleQuoteC "$'">
                              tokens: [<Id.Char_OneChar '\\n'>]
                            )
                          }
                        )
                        (command.ForEach
                          iter_name: i
                          iter_words: [
                            {(word_part.TildeSub token:<Id.Lit_TildeLike '~'>) </.mplayer/skins>}
                            {
                              (braced_var_sub
                                token: <Id.VSub_Name dirs>
                                bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                              )
                            }
                          ]
                          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.Unary
                                                      op_id: Id.BoolUnary_d
                                                      child: {($ Id.VSub_DollarName '$i')}
                                                    )
                                                  right: 
                                                    (bool_expr.Unary
                                                      op_id: Id.BoolUnary_r
                                                      child: {($ Id.VSub_DollarName '$i')}
                                                    )
                                                )
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                      action: [
                                        (command.ForEach
                                          iter_name: j
                                          iter_words: [
                                            {
                                              (command_sub
                                                left_token: <Id.Left_DollarParen '$('>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (C {<compgen>} {<-d>} {<-->} 
                                                        {($ Id.VSub_DollarName '$i') </> 
                                                          ($ Id.VSub_DollarName '$cur')
                                                        }
                                                      )
                                                    ]
                                                  )
                                              )
                                            }
                                          ]
                                          do_arg_iter: F
                                          body: 
                                            (command.DoGroup
                                              children: [
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: 
                                                        (sh_lhs_expr.IndexedName
                                                          name: COMPREPLY
                                                          index: 
                                                            (arith_expr.ArithWord
                                                              w: {($ Id.VSub_DollarName '$k')}
                                                            )
                                                        )
                                                      op: assign_op.Equal
                                                      rhs: 
                                                        {
                                                          (braced_var_sub
                                                            token: <Id.VSub_Name j>
                                                            suffix_op: 
                                                              (suffix_op.Unary
                                                                op_id: Id.VOp1_Pound
                                                                arg_word: 
                                                                  {($ Id.VSub_DollarName '$i') 
                                                                    <Id.Lit_Slash />
                                                                  }
                                                              )
                                                          )
                                                        }
                                                      spids: [763]
                                                    )
                                                  ]
                                                )
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:k)
                                                      op: assign_op.Equal
                                                      rhs: 
                                                        {
                                                          (word_part.ArithSub
                                                            anode: 
                                                              (arith_expr.UnaryAssign
                                                                op_id: Id.Arith_DPlus
                                                                child: (sh_lhs_expr.Name name:k)
                                                              )
                                                          )
                                                        }
                                                      spids: [776]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                        )
                                      ]
                                      spids: [719 736]
                                    )
                                  ]
                                )
                              ]
                            )
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [637 638 798 -1]
                    )
                    (case_arm
                      pat_list: [{<-cdrom-device>}]
                      action: [
                        (C {<_cd_devices>})
                        (C {<_dvd_devices>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [801 802 816 -1]
                    )
                    (case_arm
                      pat_list: [{<-dvd-device>}]
                      action: [
                        (C {<_dvd_devices>})
                        (C {<_filedir>} {<iso>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [819 820 836 -1]
                    )
                    (case_arm
                      pat_list: [{<-bluray-device>}]
                      action: [
                        (C {<_filedir>} {<-d>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [839 840 853 -1]
                    )
                    (case_arm
                      pat_list: [{<-mixer>} {<-dvdauth>} {<-fb>} {<-zrdev>}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:cur)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (braced_var_sub
                                    token: <Id.VSub_Name cur>
                                    suffix_op: 
                                      (suffix_op.Unary
                                        op_id: Id.VTest_ColonEquals
                                        arg_word: {<Id.Lit_Slash /> <dev> <Id.Lit_Slash />}
                                      )
                                  )
                                }
                              spids: [866]
                            )
                          ]
                        )
                        (C {<_filedir>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [856 863 884 -1]
                    )
                    (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: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [887 922 933 -1]
                    )
                    (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> <Id.Lit_LBracket '['> <wh> <Id.Lit_RBracket ']'>}
                        {<-wid>}
                        {<-monitor-dotclock>}
                        {<-monitor-> <Id.Lit_LBracket '['> <hv> <Id.Lit_RBracket ']'> <freq>}
                        {<-panscan>}
                        {<-saturation>}
                        {<-xineramascreen>}
                        {<-zrcrop>}
                        {<-zrnorm>}
                        {<-zrquality>}
                        {<-zr> <Id.Lit_LBracket '['> <xy> <Id.Lit_RBracket ']'> <doff>}
                        {<-zr> <Id.Lit_LBracket '['> <vh> <Id.Lit_RBracket ']'> <dec>}
                        {<-pp>}
                        {<-x>}
                        {<-y>}
                        {<-xy>}
                        {<-z>}
                        {<-stereo>}
                        {<-audio-density>}
                        {<-audio-delay>}
                        {<-audio-preload>}
                        {<-endpos>}
                        {<-osdlevel>}
                        {<-ffourcc>}
                        {<-sws>}
                        {<-skiplimit>}
                        {<-format>}
                        {<-ofps>}
                        {<-aadriver>}
                        {<-aaosdcolor>}
                        {<-aasubcolor>}
                        {<-vobsubout>}
                        {<-vobsuboutid>}
                        {<-vobsuboutindex>}
                        {<-sub-bg-alpha>}
                        {<-sub-bg-color>}
                        {<-subdelay>}
                        {<-subfps>}
                        {<-subpos>}
                        {<-subalign>}
                        {<-subwidth>}
                        {<-subfont-blur>}
                        {<-subfont-outline>}
                        {<-subfont-autoscale>}
                        {<-subfont-encoding>}
                        {<-subfont-osd-scale>}
                        {<-subfont-text-scale>}
                      ]
                      action: [
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [936 1179 1187 -1]
                    )
                    (case_arm
                      pat_list: [{<-channels>}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {<compgen>} {<-W>} {(SQ <'2 4 6 8'>)} {<-->} 
                                                  {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1194]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1190 1191 1223 -1]
                    )
                    (case_arm
                      pat_list: [{<-aspect>} {<-monitoraspect>}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          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 ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1232]
                            )
                          ]
                        )
                        (C {<__ltrim_colon_completions>} {(DQ ($ Id.VSub_DollarName '$cur'))})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1226 1229 1269 -1]
                    )
                    (case_arm
                      pat_list: [{<-lavdopts>}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          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 ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1276]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1272 1273 1307 -1]
                    )
                    (case_arm
                      pat_list: [{<-lavcopts>}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          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 ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1314]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1310 1311 1352 -1]
                    )
                    (case_arm
                      pat_list: [{<-ssf>}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {<compgen>} {<-W>} 
                                                  {(SQ <'lgb= cgb= ls= cs= chs= cvs='>)} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1359]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1355 1356 1390 -1]
                    )
                    (case_arm
                      pat_list: [{<-jpeg>}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {<compgen>} {<-W>} 
                                                  {
                                                    (SQ <'noprogressive progressive nobaseline\n'> 
                                                      <
'                baseline optimize= smooth= quality= outdir='
                                                      >
                                                    )
                                                  } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1397]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1393 1394 1427 -1]
                    )
                    (case_arm
                      pat_list: [{<-xvidopts>}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {<compgen>} {<-W>} {(SQ <'dr2 nodr2'>)} {<-->} 
                                                  {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1434]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1430 1431 1463 -1]
                    )
                    (case_arm
                      pat_list: [{<-xvidencopts>}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          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 ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1470]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1466 1467 1503 -1]
                    )
                    (case_arm
                      pat_list: [{<-divx4opts>}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          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 ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1510]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1506 1507 1541 -1]
                    )
                    (case_arm
                      pat_list: [{<-info>}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {<compgen>} {<-W>} 
                                                  {
                                                    (SQ <'name= artist= genre= subject=\n'> 
                                                      <
'                copyright= srcform= comment= help'
                                                      >
                                                    )
                                                  } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1548]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1544 1545 1578 -1]
                    )
                    (case_arm
                      pat_list: [{<-lameopts>}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {<compgen>} {<-W>} 
                                                  {
                                                    (SQ <'vbr= abr cbr br= q= aq= ratio= vol=\n'> 
                                                      <
'                mode= padding= fast preset= help'
                                                      >
                                                    )
                                                  } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1585]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1581 1582 1615 -1]
                    )
                    (case_arm
                      pat_list: [{<-rawaudio>}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {<compgen>} {<-W>} 
                                                  {(SQ <'on channels= rate= samplesize= format='>)} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1622]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1618 1619 1653 -1]
                    )
                    (case_arm
                      pat_list: [{<-rawvideo>}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          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 ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1660]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1656 1657 1690 -1]
                    )
                    (case_arm
                      pat_list: [{<-aop>}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {<compgen>} {<-W>} 
                                                  {
                                                    (SQ <'list= delay= format= fout= volume= mul=\n'> 
                                                      <'                softclip'>
                                                    )
                                                  } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1697]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1693 1694 1727 -1]
                    )
                    (case_arm
                      pat_list: [{<-dxr2>}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          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 ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1734]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1730 1731 1768 -1]
                    )
                    (case_arm
                      pat_list: [{<-tv>}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          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 ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1775]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1771 1772 1809 -1]
                    )
                    (case_arm
                      pat_list: [{<-mf>}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {<compgen>} {<-W>} {(SQ <'on w= h= fps= type='>)} 
                                                  {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1816]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1812 1813 1845 -1]
                    )
                    (case_arm
                      pat_list: [{<-cdda>}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {<compgen>} {<-W>} 
                                                  {
                                                    (SQ <'speed= paranoia= generic-dev=\n'> 
                                                      <
'                sector-size= overlap= toc-bias toc-offset= skip noskip'
                                                      >
                                                    )
                                                  } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1852]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1848 1849 1884 -1]
                    )
                    (case_arm
                      pat_list: [{<-input>}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {<compgen>} {<-W>} 
                                                  {
                                                    (SQ <'conf= ar-delay ar-rate keylist cmdlist\n'> 
                                                      <'                js-dev file'>
                                                    )
                                                  } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1891]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1887 1888 1921 -1]
                    )
                    (case_arm
                      pat_list: [{<-af-adv>}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {<compgen>} {<-W>} {(SQ <'force= list='>)} {<-->} 
                                                  {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1928]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1924 1925 1957 -1]
                    )
                    (case_arm
                      pat_list: [{<-noconfig>}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {<compgen>} {<-W>} {(SQ <'all gui system user'>)} 
                                                  {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1964]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1960 1961 1993 -1]
                    )
                    (case_arm
                      pat_list: [{<-> <Id.Lit_Star '*'>}]
                      action: [
                        (command.AndOr
                          ops: [Id.Op_DPipe]
                          children: [
                            (command.Pipeline
                              children: [
                                (command.Simple
                                  words: [
                                    {($ Id.VSub_DollarName '$cmd')}
                                    {<-nomsgcolor>}
                                    {<-nomsgmodule>}
                                    {<-list-options>}
                                  ]
                                  redirects: [
                                    (redir.Redir
                                      op: <Id.Redir_Great '2>'>
                                      fd: 2
                                      arg_word: {</dev/null>}
                                    )
                                  ]
                                )
                                (command.WhileUntil
                                  keyword: <Id.KW_While while>
                                  cond: [
                                    (command.Sentence
                                      child: (C {<read>} {<-r>} {<i>} {<j>} {<k>})
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                  body: 
                                    (command.DoGroup
                                      children: [
                                        (command.If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (command.Sentence
                                                  child: 
                                                    (command.DBracket
                                                      expr: 
                                                        (bool_expr.Binary
                                                          op_id: Id.BoolBinary_GlobDEqual
                                                          left: {($ Id.VSub_DollarName '$i')}
                                                          right: 
                                                            {
                                                              (braced_var_sub
                                                                token: <Id.VSub_Name prev>
                                                                suffix_op: 
                                                                  (suffix_op.Unary
                                                                    op_id: Id.VOp1_Pound
                                                                    arg_word: {<->}
                                                                  )
                                                              )
                                                            }
                                                        )
                                                    )
                                                  terminator: <Id.Op_Semi _>
                                                )
                                              ]
                                              action: [
                                                (command.AndOr
                                                  ops: [Id.Op_DAmp]
                                                  children: [
                                                    (command.DBracket
                                                      expr: 
                                                        (bool_expr.Binary
                                                          op_id: Id.BoolBinary_GlobNEqual
                                                          left: 
                                                            {
                                                              (braced_var_sub
                                                                token: <Id.VSub_Name j>
                                                                suffix_op: 
                                                                  (suffix_op.Unary
                                                                    op_id: Id.VOp1_DComma
                                                                    arg_word: {}
                                                                  )
                                                              )
                                                            }
                                                          right: 
                                                            {
                                                              (word_part.ExtGlob
                                                                op: <Id.ExtGlob_At '@('>
                                                                arms: [{<flag>} {<print>}]
                                                              )
                                                            }
                                                        )
                                                    )
                                                    (command.ControlFlow
                                                      token: <Id.ControlFlow_Return return>
                                                      arg_word: {<1>}
                                                    )
                                                  ]
                                                )
                                                (command.ControlFlow
                                                  token: <Id.ControlFlow_Break break>
                                                )
                                              ]
                                              spids: [2040 2057]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                )
                              ]
                              negated: F
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                              arg_word: {<0>}
                            )
                          ]
                        )
                      ]
                      spids: [1996 1998 2099 -1]
                    )
                  ]
                )
                (command.Case
                  to_match: {($ Id.VSub_DollarName '$cur')}
                  arms: [
                    (case_arm
                      pat_list: [{<-> <Id.Lit_Star '*'>}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {<compgen>} {<-W>} 
                                                  {
                                                    (SQ 
                                                      <
'$( $cmd -nomsgcolor -nomsgmodule -list-options 2>/dev/null | \\\n'
                                                      > <'                sed -ne '>
                                                    ) <1> <Id.Lit_Comma ','> </> <Id.Lit_Other '^'> <Id.KW_DLeftBracket '[['> <Id.Lit_Other ':'> <space> 
                                                    <Id.Lit_Other ':'> <Id.Lit_RBracket ']'> <Id.Lit_RBracket ']'> <Id.Lit_Star '*'> <Name/d> 
                                                    (SQ <' \\\n'> 
                                                      <
'                    -e "s/^[[:space:]]*/-/" -e "s/[[:space:]:].*//" \\\n'
                                                      > <'                    -e "/^-\\(Total\\|.*\\*\\)\\{0,1\\}$/!p" )'>
                                                    )
                                                  } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [2118]
                            )
                          ]
                        )
                      ]
                      spids: [2113 2115 2160 -1]
                    )
                    (case_arm
                      pat_list: [{<Id.Lit_Star '*'>}]
                      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: [2163 2164 2174 -1]
                    )
                  ]
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<0>}
                )
              ]
            )
        )
        (C {<complete>} {<-F>} {<_mplayer>} {<mplayer>} {<mplayer2>} {<mencoder>} {<gmplayer>} {<kplayer>})
      ]
    )
  ]
)