(command.CommandList
  children: [
    (command.ShFunction
      name: _muttaddr
      body: 
        (command.BraceGroup
          children: [
            (C {<_muttaliases>} {(DQ ($ Id.VSub_Number '$1'))})
            (C {<_muttquery>} {(DQ ($ Id.VSub_Number '$1'))})
            (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>} {<-u>} {<-->} {(DQ ($ Id.VSub_Number '$1'))})
                                  ]
                                )
                            )
                          }
                        ]
                      )
                    }
                  spids: [38]
                )
              ]
            )
            (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<0>})
          ]
        )
    )
    (command.ShFunction
      name: _muttrc
      body: 
        (command.BraceGroup
          children: [
            (C {<Id.KW_Set set>} {<-->} 
              {
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name words>
                    bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                  )
                )
              }
            )
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: [
                (command.Sentence
                  child: 
                    (command.DBracket
                      expr: 
                        (bool_expr.Binary
                          op_id: Id.BoolBinary_gt
                          left: {($ Id.VSub_Pound '$#')}
                          right: {<0>}
                        )
                    )
                  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_Number '$1')}
                                      right: {<-F> <Id.Lit_Other '*'>}
                                    )
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_gt
                                              left: 
                                                {
                                                  (braced_var_sub
                                                    token: <Id.VSub_Number 1>
                                                    prefix_op: (Id.VSub_Pound)
                                                  )
                                                }
                                              right: {<2>}
                                            )
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:muttrc)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (command_sub
                                                  left_token: <Id.Left_DollarParen '$('>
                                                  command_list: 
                                                    (command.CommandList
                                                      children: [
                                                        (C {<dequote>} 
                                                          {
                                                            (DQ 
                                                              (braced_var_sub
                                                                token: <Id.VSub_Number 1>
                                                                suffix_op: 
                                                                  (suffix_op.Slice
                                                                    begin: 
                                                                      (arith_expr.ArithWord
                                                                        w: {<Id.Lit_Digits 2>}
                                                                      )
                                                                  )
                                                              )
                                                            )
                                                          }
                                                        )
                                                      ]
                                                    )
                                                )
                                              )
                                            }
                                          spids: [150]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [131 147]
                                )
                              ]
                              else_action: [
                                (C {<shift>})
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (command.DBracket
                                      expr: (bool_expr.WordTest w:{($ Id.VSub_Number '$1')})
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:muttrc)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (command_sub
                                                  left_token: <Id.Left_DollarParen '$('>
                                                  command_list: 
                                                    (command.CommandList
                                                      children: [
                                                        (C {<dequote>} {(DQ ($ Id.VSub_Number '$1'))})
                                                      ]
                                                    )
                                                )
                                              )
                                            }
                                          spids: [180]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [114 128]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                )
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_z
                              child: {($ Id.VSub_DollarName '$muttrc')}
                            )
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Unary
                                      op_id: Id.BoolUnary_f
                                      child: 
                                        {<Id.Lit_TildeLike '~'> </.> (${ Id.VSub_Name muttcmd) <rc>}
                                    )
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:muttrc)
                                  op: assign_op.Equal
                                  rhs: {(DQ <'~/.'> (${ Id.VSub_Name muttcmd) <rc>)}
                                  spids: [241]
                                )
                              ]
                            )
                          ]
                          spids: [222 238]
                        )
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Unary
                                      op_id: Id.BoolUnary_f
                                      child: 
                                        {<Id.Lit_TildeLike '~'> </.> (${ Id.VSub_Name muttcmd) </> 
                                          (${ Id.VSub_Name muttcmd) <rc>
                                        }
                                    )
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:muttrc)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ <'~/.'> (${ Id.VSub_Name muttcmd) </> 
                                        (${ Id.VSub_Name muttcmd) <rc>
                                      )
                                    }
                                  spids: [274]
                                )
                              ]
                            )
                          ]
                          spids: [251 271]
                        )
                      ]
                    )
                  ]
                  spids: [208 219]
                )
              ]
            )
            (C {<printf>} {(DQ <'%s'>)} {(DQ ($ Id.VSub_DollarName '$muttrc'))})
          ]
        )
    )
    (command.ShFunction
      name: _muttconffiles
      body: 
        (command.BraceGroup
          children: [
            (C {<local>} {<file>} {<sofar>})
            (C {<local>} {<-a>} {<newconffiles>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:sofar)
                  op: assign_op.Equal
                  rhs: {(DQ <' '> ($ Id.VSub_Number '$1') <' '>)}
                  spids: [342]
                )
              ]
            )
            (C {<shift>})
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: [
                (command.Sentence
                  child: (command.DBracket expr:(bool_expr.WordTest w:{(DQ ($ Id.VSub_Number '$1'))}))
                  terminator: <Id.Op_Semi _>
                )
              ]
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:newconffiles)
                          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 {<sed>} {<-n>} 
                                              {
                                                (SQ 
                                                  <
's|^source[[:space:]]\\{1,\\}\\([^[:space:]]\\{1,\\}\\).*$|\\1|p'
                                                  >
                                                )
                                              } 
                                              {
                                                (command_sub
                                                  left_token: <Id.Left_DollarParen '$('>
                                                  command_list: 
                                                    (command.CommandList
                                                      children: [
                                                        (C {<eval>} {<printf>} {<Id.Lit_Other '%'> <s>} 
                                                          {($ Id.VSub_Number '$1')}
                                                        )
                                                      ]
                                                    )
                                                )
                                              }
                                            )
                                          ]
                                        )
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [367]
                        )
                      ]
                    )
                    (command.ForEach
                      iter_name: file
                      iter_words: [
                        {
                          (DQ 
                            (braced_var_sub
                              token: <Id.VSub_Name newconffiles>
                              bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                            )
                          )
                        }
                      ]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (C {<__expand_tilde_by_ref>} {<file>})
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.LogicalOr
                                      left: 
                                        (bool_expr.LogicalNot
                                          child: 
                                            (bool_expr.Unary
                                              op_id: Id.BoolUnary_f
                                              child: {(DQ ($ Id.VSub_DollarName '$file'))}
                                            )
                                        )
                                      right: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {($ Id.VSub_DollarName '$sofar')}
                                          right: 
                                            {<Id.Lit_Other '*'> 
                                              (word_part.EscapedLiteral
                                                token: <Id.Lit_EscapedChar '\\ '>
                                              ) ($ Id.VSub_DollarName '$file') (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\ '>) 
                                              <Id.Lit_Other '*'>
                                            }
                                        )
                                    )
                                )
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Continue continue>
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:sofar)
                                  op: assign_op.PlusEqual
                                  rhs: {(DQ <' '> ($ Id.VSub_DollarName '$file'))}
                                  spids: [448]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:sofar)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ <' '> 
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {<eval>} {<_muttconffiles>} 
                                                  {
                                                    (word_part.EscapedLiteral
                                                      token: <Id.Lit_EscapedChar '\\"'>
                                                    ) ($ Id.VSub_DollarName '$sofar') (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>)
                                                  } {($ Id.VSub_DollarName '$file')}
                                                )
                                              ]
                                            )
                                        ) <' '>
                                      )
                                    }
                                  spids: [455]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (C {<shift>})
                  ]
                )
            )
            (C {<printf>} {(SQ <'%s\\n'>)} {($ Id.VSub_DollarName '$sofar')})
          ]
        )
    )
    (command.ShFunction
      name: _muttaliases
      body: 
        (command.BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'cur='> ($ Id.VSub_Number '$1')} {<muttrc>} 
              {<Id.Lit_VarLike 'muttcmd='> 
                (braced_var_sub
                  token: <Id.VSub_Name words>
                  bracket_op: (bracket_op.ArrayIndex expr:(arith_expr.ArithWord w:{<Id.Lit_Digits 0>}))
                )
              }
            )
            (C {<local>} {<-a>} {<conffiles>} {<aliases>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:muttrc)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        command_list: (command.CommandList children:[(C {<_muttrc>})])
                      )
                    }
                  spids: [530]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DBracket
                  expr: (bool_expr.Unary op_id:Id.BoolUnary_z child:{($ Id.VSub_DollarName '$muttrc')})
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<0>}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:conffiles)
                  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 {<eval>} {<_muttconffiles>} {($ Id.VSub_DollarName '$muttrc')} 
                                      {($ Id.VSub_DollarName '$muttrc')}
                                    )
                                  ]
                                )
                            )
                          }
                        ]
                      )
                    }
                  spids: [552]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:aliases)
                  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 {<sed>} {<-n>} 
                                      {
                                        (SQ 
                                          <
's|^alias[[:space:]]\\{1,\\}\\([^[:space:]]\\{1,\\}\\).*$|\\1|p'
                                          >
                                        )
                                      } 
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {<eval>} {<echo>} 
                                                  {
                                                    (DQ 
                                                      (braced_var_sub
                                                        token: <Id.VSub_Name conffiles>
                                                        bracket_op: 
                                                          (bracket_op.WholeArray
                                                            op_id: Id.Lit_At
                                                          )
                                                      )
                                                    )
                                                  }
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    )
                                  ]
                                )
                            )
                          }
                        ]
                      )
                    }
                  spids: [568]
                )
              ]
            )
            (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>} 
                                      {
                                        (DQ 
                                          (braced_var_sub
                                            token: <Id.VSub_Name aliases>
                                            bracket_op: (bracket_op.WholeArray op_id:Id.Arith_Star)
                                          )
                                        )
                                      } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                    )
                                  ]
                                )
                            )
                          }
                        ]
                      )
                    }
                  spids: [603]
                )
              ]
            )
            (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<0>})
          ]
        )
    )
    (command.ShFunction
      name: _muttquery
      body: 
        (command.BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'cur='> ($ Id.VSub_Number '$1')} {<querycmd>} 
              {<Id.Lit_VarLike 'muttcmd='> 
                (braced_var_sub
                  token: <Id.VSub_Name words>
                  bracket_op: (bracket_op.ArrayIndex expr:(arith_expr.ArithWord w:{<Id.Lit_Digits 0>}))
                )
              }
            )
            (C {<local>} {<-a>} {<queryresults>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:querycmd)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (command_sub
                          left_token: <Id.Left_DollarParen '$('>
                          command_list: 
                            (command.CommandList
                              children: [
                                (command.Pipeline
                                  children: [
                                    (command.Simple
                                      words: [
                                        {($ Id.VSub_DollarName '$muttcmd')}
                                        {<-Q>}
                                        {<query_command>}
                                      ]
                                      redirects: [
                                        (redir.Redir
                                          op: <Id.Redir_Great '2>'>
                                          fd: 2
                                          arg_word: {</dev/null>}
                                        )
                                      ]
                                    )
                                    (C {<sed>} {<-e>} {(SQ <'s|^query_command=\\"\\(.*\\)\\"$|\\1|'>)} 
                                      {<-e>} {(SQ <'s|%s|'>) ($ Id.VSub_DollarName '$cur') (SQ <'|'>)}
                                    )
                                  ]
                                  negated: F
                                )
                              ]
                            )
                        )
                      )
                    }
                  spids: [675]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.LogicalOr
                              left: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_z
                                  child: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                )
                              right: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_z
                                  child: {(DQ ($ Id.VSub_DollarName '$querycmd'))}
                                )
                            )
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:queryresults)
                          op: assign_op.Equal
                          rhs: {(sh_array_literal left:<Id.Op_LParen _>)}
                          spids: [736]
                        )
                      ]
                    )
                  ]
                  spids: [712 733]
                )
              ]
              else_action: [
                (C {<__expand_tilde_by_ref>} {<querycmd>})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:queryresults)
                      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: [
                                            (C {($ Id.VSub_DollarName '$querycmd')})
                                            (C {<sed>} {<-n>} 
                                              {(SQ <'2,$s|^\\([^[:space:]]\\{1,\\}\\).*|\\1|p'>)}
                                            )
                                          ]
                                          negated: F
                                        )
                                      ]
                                    )
                                )
                              }
                            ]
                          )
                        }
                      spids: [749]
                    )
                  ]
                )
              ]
            )
            (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>} 
                                      {
                                        (DQ 
                                          (braced_var_sub
                                            token: <Id.VSub_Name queryresults>
                                            bracket_op: (bracket_op.WholeArray op_id:Id.Arith_Star)
                                          )
                                        )
                                      } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                    )
                                  ]
                                )
                            )
                          }
                        ]
                      )
                    }
                  spids: [777]
                )
              ]
            )
            (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<0>})
          ]
        )
    )
    (command.ShFunction
      name: _muttfiledir
      body: 
        (command.BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'cur='> ($ Id.VSub_Number '$1')} {<folder>} {<muttrc>} 
              {<spoolfile>} 
              {<Id.Lit_VarLike 'muttcmd='> 
                (braced_var_sub
                  token: <Id.VSub_Name words>
                  bracket_op: (bracket_op.ArrayIndex expr:(arith_expr.ArithWord w:{<Id.Lit_Digits 0>}))
                )
              }
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:muttrc)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        command_list: (command.CommandList children:[(C {<_muttrc>})])
                      )
                    }
                  spids: [846]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobDEqual
                              left: {($ Id.VSub_DollarName '$cur')}
                              right: 
                                {<Id.Lit_Other '['> <Id.BoolBinary_GlobEqual '='> <Id.Lit_Other '+'> 
                                  <Id.Lit_Other ']'> <Id.Lit_Other '*'>
                                }
                            )
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:folder)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (command_sub
                                  left_token: <Id.Left_DollarParen '$('>
                                  command_list: 
                                    (command.CommandList
                                      children: [
                                        (command.Pipeline
                                          children: [
                                            (command.Simple
                                              words: [
                                                {($ Id.VSub_DollarName '$muttcmd')}
                                                {<-F>}
                                                {(DQ ($ Id.VSub_DollarName '$muttrc'))}
                                                {<-Q>}
                                                {<folder>}
                                              ]
                                              redirects: [
                                                (redir.Redir
                                                  op: <Id.Redir_Great '2>'>
                                                  fd: 2
                                                  arg_word: {</dev/null>}
                                                )
                                              ]
                                            )
                                            (C {<sed>} {<-e>} {(SQ <'s|^folder=\\"\\(.*\\)\\"$|\\1|'>)})
                                          ]
                                          negated: F
                                        )
                                      ]
                                    )
                                )
                              )
                            }
                          spids: [872]
                        )
                      ]
                    )
                    (C {<Id.Lit_Other ':'>} 
                      {<folder> <Id.Lit_Other ':'> <Id.Lit_Equals '='> <Id.Lit_TildeLike '~'> </Mail>}
                    )
                    (C {<compopt>} {<-o>} {<filenames>})
                    (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>} {<-f>} {<-->} 
                                              {
                                                (DQ ($ Id.VSub_DollarName '$folder') </> 
                                                  (braced_var_sub
                                                    token: <Id.VSub_Name cur>
                                                    suffix_op: 
                                                      (suffix_op.Slice
                                                        begin: 
                                                          (arith_expr.ArithWord
                                                            w: {<Id.Lit_Digits 1>}
                                                          )
                                                      )
                                                  )
                                                )
                                              }
                                            )
                                          ]
                                        )
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [930]
                        )
                      ]
                    )
                    (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: [
                                  {
                                    (braced_var_sub
                                      token: <Id.VSub_Name COMPREPLY>
                                      bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                      suffix_op: 
                                        (suffix_op.Unary
                                          op_id: Id.VOp1_Pound
                                          arg_word: 
                                            {($ Id.VSub_DollarName '$folder') <Id.Lit_Slash />}
                                        )
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [956]
                        )
                      ]
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [852 869]
                )
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobDEqual
                              left: {($ Id.VSub_DollarName '$cur')}
                              right: {<Id.KW_Bang '!'> <Id.Lit_Other '*'>}
                            )
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:spoolfile)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (command_sub
                                  left_token: <Id.Left_DollarParen '$('>
                                  command_list: 
                                    (command.CommandList
                                      children: [
                                        (command.Pipeline
                                          children: [
                                            (command.Simple
                                              words: [
                                                {($ Id.VSub_DollarName '$muttcmd')}
                                                {<-F>}
                                                {(DQ ($ Id.VSub_DollarName '$muttrc'))}
                                                {<-Q>}
                                                {<spoolfile>}
                                              ]
                                              redirects: [
                                                (redir.Redir
                                                  op: <Id.Redir_Great '2>'>
                                                  fd: 2
                                                  arg_word: {</dev/null>}
                                                )
                                              ]
                                            )
                                            (C {<sed>} {<-e>} 
                                              {(SQ <'s|^spoolfile=\\"\\(.*\\)\\"$|\\1|'>)}
                                            )
                                          ]
                                          negated: F
                                        )
                                      ]
                                    )
                                )
                              )
                            }
                          spids: [994]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.LogicalNot
                              child: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_z
                                  child: {($ Id.VSub_DollarName '$spoolfile')}
                                )
                            )
                        )
                        (C {<eval>} 
                          {<Id.Lit_VarLike 'cur='> 
                            (DQ 
                              (braced_var_sub
                                token: <Id.VSub_Name cur>
                                suffix_op: 
                                  (suffix_op.PatSub
                                    pat: {<'^!'>}
                                    replace: {($ Id.VSub_DollarName '$spoolfile')}
                                    replace_mode: Id.Undefined_Tok
                                  )
                              )
                            )
                          }
                        )
                      ]
                    )
                  ]
                  spids: [977 991]
                )
              ]
            )
            (C {<_filedir>})
            (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<0>})
          ]
        )
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (command.ShFunction
          name: _mutt
          body: 
            (command.BraceGroup
              children: [
                (C {<local>} {<cur>} {<prev>} {<words>} {<cword>})
                (command.AndOr
                  ops: [Id.Op_DPipe]
                  children: [
                    (C {<_init_completion>} {<-n>} 
                      {<Id.Lit_Equals '='> <Id.Lit_Other '+'> <Id.KW_Bang '!'>}
                    )
                    (command.ControlFlow token:<Id.ControlFlow_Return return>)
                  ]
                )
                (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 
                                                      <
'-A -a -b -c -e -f -F -H -i -m -n -p -Q -R -s\n'
                                                      > <'            -v -x -y -z -Z -h'>
                                                    )
                                                  } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1114]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1109 1111 1144 -1]
                    )
                    (case_arm
                      pat_list: [{<Id.Lit_Star '*'>}]
                      action: [
                        (command.Case
                          to_match: {($ Id.VSub_DollarName '$prev')}
                          arms: [
                            (case_arm
                              pat_list: [{<-a>} {<-f>} {<-F>} {<-H>} {<-i>}]
                              action: [
                                (C {<_muttfiledir>} {(DQ ($ Id.VSub_DollarName '$cur'))})
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Return return>
                                  arg_word: {<0>}
                                )
                              ]
                              spids: [1158 1167 1182 -1]
                            )
                            (case_arm
                              pat_list: [{<-A>}]
                              action: [
                                (C {<_muttaliases>} {(DQ ($ Id.VSub_DollarName '$cur'))})
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Return return>
                                  arg_word: {<0>}
                                )
                              ]
                              spids: [1185 1186 1201 -1]
                            )
                            (case_arm
                              pat_list: [
                                {<-e>}
                                {<-m>}
                                {<-Q>}
                                {<-s>}
                                {<-h>}
                                {<-p>}
                                {<-R>}
                                {<-v>}
                                {<-y>}
                                {<-z>}
                                {<-Z>}
                              ]
                              action: [
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Return return>
                                  arg_word: {<0>}
                                )
                              ]
                              spids: [1204 1225 1233 -1]
                            )
                            (case_arm
                              pat_list: [{<Id.Lit_Star '*'>}]
                              action: [
                                (C {<_muttaddr>} {(DQ ($ Id.VSub_DollarName '$cur'))})
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Return return>
                                  arg_word: {<0>}
                                )
                              ]
                              spids: [1236 1237 1252 -1]
                            )
                          ]
                        )
                      ]
                      spids: [1147 1148 1258 -1]
                    )
                  ]
                )
              ]
            )
        )
        (C {<complete>} {<-F>} {<_mutt>} {<-o>} {<default>} {<mutt>} {<muttng>})
      ]
    )
  ]
)