(command.AndOr
  children: [
    (command.ShFunction
      name_tok: <_rsync>
      name: _rsync
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <local>
              more_env: []
              words: [{<local>} {<cur>} {<prev>} {<words>} {<cword>} {<split>}]
              redirects: []
              do_fork: T
            )
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <_init_completion>
                  more_env: []
                  words: [{<_init_completion>} {<-s>} {<-n>} {<Id.Lit_Colon ':'>}]
                  redirects: []
                  do_fork: T
                )
                (command.ControlFlow keyword:<Id.ControlFlow_Return return>)
              ]
              ops: [<Id.Op_DPipe _>]
            )
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <_expand>
                  more_env: []
                  words: [{<_expand>}]
                  redirects: []
                  do_fork: T
                )
                (command.ControlFlow
                  keyword: <Id.ControlFlow_Return return>
                  arg_word: {<0>}
                )
              ]
              ops: [<Id.Op_DPipe _>]
            )
            (command.Case
              case_kw: <Id.KW_Case case>
              to_match: (case_arg.Word w:{($ Id.VSub_DollarName prev)})
              arms_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <--config>
                  pattern: 
                    (pat.Words
                      words: [
                        {<--config>}
                        {<--password-file>}
                        {<--include-from>}
                        {<--exclude-from>}
                        {<--files-from>}
                        {<--log-file>}
                        {<--write-batch>}
                        {<--only-write-batch>}
                        {<--read-batch>}
                      ]
                    )
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.Simple
                      blame_tok: <compopt>
                      more_env: []
                      words: [{<compopt>} {<Id.Lit_Other '+'> <o>} {<nospace>}]
                      redirects: []
                      do_fork: T
                    )
                    (command.Simple
                      blame_tok: <_filedir>
                      more_env: []
                      words: [{<_filedir>}]
                      redirects: []
                      do_fork: T
                    )
                    (command.ControlFlow
                      keyword: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <-T>
                  pattern: 
                    (pat.Words
                      words: [
                        {<-T>}
                        {<--temp-dir>}
                        {<--compare-dest>}
                        {<--backup-dir>}
                        {<--partial-dir>}
                        {<--copy-dest>}
                        {<--link-dest>}
                      ]
                    )
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.Simple
                      blame_tok: <compopt>
                      more_env: []
                      words: [{<compopt>} {<Id.Lit_Other '+'> <o>} {<nospace>}]
                      redirects: []
                      do_fork: T
                    )
                    (command.Simple
                      blame_tok: <_filedir>
                      more_env: []
                      words: [{<_filedir>} {<-d>}]
                      redirects: []
                      do_fork: T
                    )
                    (command.ControlFlow
                      keyword: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <-e>
                  pattern: (pat.Words words:[{<-e>} {<--rsh>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.Simple
                      blame_tok: <compopt>
                      more_env: []
                      words: [{<compopt>} {<Id.Lit_Other '+'> <o>} {<nospace>}]
                      redirects: []
                      do_fork: T
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'COMPREPLY='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'COMPREPLY='> name:COMPREPLY)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (ShArrayLiteral
                                left: <Id.Op_LParen _>
                                words: [
                                  {
                                    (CommandSub
                                      left_token: <Id.Left_DollarParen '$('>
                                      child: 
                                        (command.Simple
                                          blame_tok: <compgen>
                                          more_env: []
                                          words: [
                                            {<compgen>}
                                            {<-W>}
                                            {(SQ <'rsh ssh'>)}
                                            {<-->}
                                            {(DQ ($ Id.VSub_DollarName cur))}
                                          ]
                                          redirects: []
                                          do_fork: T
                                        )
                                      right: <Id.Eof_RParen _>
                                    )
                                  }
                                ]
                                right: <Id.Right_ShArrayLiteral _>
                              )
                            }
                        )
                      ]
                      redirects: []
                    )
                    (command.ControlFlow
                      keyword: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <--compress-level>
                  pattern: (pat.Words words:[{<--compress-level>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.Simple
                      blame_tok: <compopt>
                      more_env: []
                      words: [{<compopt>} {<Id.Lit_Other '+'> <o>} {<nospace>}]
                      redirects: []
                      do_fork: T
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'COMPREPLY='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'COMPREPLY='> name:COMPREPLY)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (ShArrayLiteral
                                left: <Id.Op_LParen _>
                                words: [
                                  {
                                    (CommandSub
                                      left_token: <Id.Left_DollarParen '$('>
                                      child: 
                                        (command.Simple
                                          blame_tok: <compgen>
                                          more_env: []
                                          words: [
                                            {<compgen>}
                                            {<-W>}
                                            {(SQ <'{1..9}'>)}
                                            {<-->}
                                            {(DQ ($ Id.VSub_DollarName cur))}
                                          ]
                                          redirects: []
                                          do_fork: T
                                        )
                                      right: <Id.Eof_RParen _>
                                    )
                                  }
                                ]
                                right: <Id.Right_ShArrayLiteral _>
                              )
                            }
                        )
                      ]
                      redirects: []
                    )
                    (command.ControlFlow
                      keyword: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <Id.VSub_DollarName '$split'>
                  more_env: []
                  words: [{($ Id.VSub_DollarName split)}]
                  redirects: []
                  do_fork: T
                )
                (command.ControlFlow
                  keyword: <Id.ControlFlow_Return return>
                  arg_word: {<0>}
                )
              ]
              ops: [<Id.Op_DAmp _>]
            )
            (command.Case
              case_kw: <Id.KW_Case case>
              to_match: (case_arg.Word w:{($ Id.VSub_DollarName cur)})
              arms_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <->
                  pattern: (pat.Words words:[{<-> <Id.Lit_Star '*'>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'COMPREPLY='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'COMPREPLY='> name:COMPREPLY)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (ShArrayLiteral
                                left: <Id.Op_LParen _>
                                words: [
                                  {
                                    (CommandSub
                                      left_token: <Id.Left_DollarParen '$('>
                                      child: 
                                        (command.Simple
                                          blame_tok: <compgen>
                                          more_env: []
                                          words: [
                                            {<compgen>}
                                            {<-W>}
                                            {
                                              (SQ <'--verbose --quiet --no-motd --checksum\n'> 
                                                <
'                --archive --recursive --relative --no-implied-dirs\n'
                                                > <'                --backup --backup-dir= --suffix= --update --inplace --append\n'> 
                                                <
'                --append-verify --dirs --old-dirs --links --copy-links\n'
                                                > <'                --copy-unsafe-links --safe-links --copy-dirlinks\n'> 
                                                <
'                --keep-dirlinks --hard-links --perms --executability --chmod=\n'
                                                > <'                --acls --xattrs --owner --group --devices --copy-devices\n'> 
                                                <
'                --specials --times --omit-dir-times --super --fake-super\n'
                                                > <'                --sparse --dry-run --whole-file --no-whole-file\n'> 
                                                <
'                --one-file-system --block-size= --rsh= --rsync-path=\n'
                                                > <'                --existing --ignore-existing --remove-source-files --delete\n'> 
                                                <
'                --delete-before --delete-during --delete-delay --delete-after\n'
                                                > <'                --delete-excluded --ignore-errors --force --max-delete=\n'> 
                                                <
'                --max-size= --min-size= --partial --partial-dir=\n'
                                                > <'                --delay-updates --prune-empty-dirs --numeric-ids --timeout=\n'> 
                                                <
'                --contimeout= --ignore-times --size-only --modify-window=\n'
                                                > <'                --temp-dir= --fuzzy --compare-dest= --copy-dest= --link-dest=\n'> 
                                                <
'                --compress --compress-level= --skip-compress= --cvs-exclude\n'
                                                > <'                --filter= --exclude= --exclude-from= --include= --include-from=\n'> 
                                                <
'                --files-from= --from0 --protect-args --address= --port=\n'
                                                > <'                --sockopts= --blocking-io --no-blocking-io --stats\n'> 
                                                <
'                --8-bit-output --human-readable --progress --itemize-changes\n'
                                                > <'                --out-format= --log-file= --log-file-format= --password-file=\n'> 
                                                <
'                --list-only --bwlimit= --write-batch= --only-write-batch=\n'
                                                > <'                --read-batch= --protocol= --iconv= --ipv4 --ipv6 --version\n'> 
                                                <
'                --help --daemon --config= --no-detach'
                                                >
                                              )
                                            }
                                            {<-->}
                                            {(DQ ($ Id.VSub_DollarName cur))}
                                          ]
                                          redirects: []
                                          do_fork: T
                                        )
                                      right: <Id.Eof_RParen _>
                                    )
                                  }
                                ]
                                right: <Id.Right_ShArrayLiteral _>
                              )
                            }
                        )
                      ]
                      redirects: []
                    )
                    (command.AndOr
                      children: [
                        (command.DBracket
                          left: <Id.KW_DLeftBracket '[['>
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobDEqual
                              left: {($ Id.VSub_DollarName COMPREPLY)}
                              right: {<Id.Lit_Other '*'> <Id.BoolBinary_GlobEqual '='>}
                            )
                          right: <Id.Lit_DRightBracket ']]'>
                          redirects: []
                        )
                        (command.Simple
                          blame_tok: <compopt>
                          more_env: []
                          words: [{<compopt>} {<Id.Lit_Other '+'> <o>} {<nospace>}]
                          redirects: []
                          do_fork: T
                        )
                      ]
                      ops: [<Id.Op_DPipe _>]
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <Id.Lit_Star '*'>
                  pattern: 
                    (pat.Words
                      words: [{<Id.Lit_Star '*'> <Id.Lit_Colon ':'> <Id.Lit_Star '*'>}]
                    )
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.Simple
                      blame_tok: <local>
                      more_env: []
                      words: [{<local>} {<i>} {<Id.Lit_VarLike 'shell='> <ssh>}]
                      redirects: []
                      do_fork: T
                    )
                    (command.ForExpr
                      keyword: <Id.KW_For for>
                      init: 
                        (arith_expr.BinaryAssign
                          op_id: Id.Arith_Equal
                          left: ($ Id.Lit_ArithVarLike i)
                          right: {<Id.Lit_Digits 1>}
                        )
                      cond: 
                        (arith_expr.Binary
                          op_id: Id.Arith_Less
                          left: ($ Id.Lit_ArithVarLike i)
                          right: ($ Id.Lit_ArithVarLike cword)
                        )
                      update: 
                        (arith_expr.UnaryAssign
                          op_id: Id.Node_PostDPlus
                          child: ($ Id.Lit_ArithVarLike i)
                        )
                      body: 
                        (command.DoGroup
                          left: <Id.KW_Do do>
                          children: [
                            (command.If
                              if_kw: <Id.KW_If if>
                              arms: [
                                (IfArm
                                  keyword: <Id.KW_If if>
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.DBracket
                                              left: <Id.KW_DLeftBracket '[['>
                                              expr: 
                                                (bool_expr.Binary
                                                  op_id: Id.BoolBinary_GlobDEqual
                                                  left: 
                                                    {
                                                      (DQ 
                                                        (BracedVarSub
                                                          left: <Id.Left_DollarBrace '${'>
                                                          token: <Id.VSub_Name words>
                                                          var_name: words
                                                          bracket_op: 
                                                            (bracket_op.ArrayIndex
                                                              expr: ($ Id.Lit_ArithVarLike i)
                                                            )
                                                          right: <Id.Right_DollarBrace '}'>
                                                        )
                                                      )
                                                    }
                                                  right: 
                                                    {<-> 
                                                      (word_part.ExtGlob
                                                        op: <Id.ExtGlob_At '@('>
                                                        arms: [{<e>} {<-rsh>}]
                                                        right: <Id.Right_ExtGlob _>
                                                      )
                                                    }
                                                )
                                              right: <Id.Lit_DRightBracket ']]'>
                                              redirects: []
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  then_kw: <Id.KW_Then then>
                                  action: [
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'shell='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'shell='>
                                          lhs: 
                                            (sh_lhs_expr.Name
                                              left: <Id.Lit_VarLike 'shell='>
                                              name: shell
                                            )
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (BracedVarSub
                                                left: <Id.Left_DollarBrace '${'>
                                                token: <Id.VSub_Name words>
                                                var_name: words
                                                bracket_op: 
                                                  (bracket_op.ArrayIndex
                                                    expr: 
                                                      (arith_expr.Binary
                                                        op_id: Id.Arith_Plus
                                                        left: ($ Id.Lit_ArithVarLike i)
                                                        right: {<Id.Lit_Digits 1>}
                                                      )
                                                  )
                                                right: <Id.Right_DollarBrace '}'>
                                              )
                                            }
                                        )
                                      ]
                                      redirects: []
                                    )
                                    (command.ControlFlow
                                      keyword: <Id.ControlFlow_Break break>
                                    )
                                  ]
                                  spids: [368 393]
                                )
                              ]
                              else_action: []
                              fi_kw: <Id.KW_Fi fi>
                              redirects: []
                            )
                          ]
                          right: <Id.KW_Done done>
                        )
                      redirects: []
                    )
                    (command.AndOr
                      children: [
                        (command.DBracket
                          left: <Id.KW_DLeftBracket '[['>
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobDEqual
                              left: {($ Id.VSub_DollarName shell)}
                              right: {<ssh>}
                            )
                          right: <Id.Lit_DRightBracket ']]'>
                          redirects: []
                        )
                        (command.Simple
                          blame_tok: <_xfunc>
                          more_env: []
                          words: [{<_xfunc>} {<ssh>} {<_scp_remote_files>}]
                          redirects: []
                          do_fork: T
                        )
                      ]
                      ops: [<Id.Op_DAmp _>]
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <Id.Lit_Star '*'>
                  pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.Simple
                      blame_tok: <_known_hosts_real>
                      more_env: []
                      words: [{<_known_hosts_real>} {<-c>} {<-a>} {(DQ ($ Id.VSub_DollarName cur))}]
                      redirects: []
                      do_fork: T
                    )
                    (command.Simple
                      blame_tok: <_xfunc>
                      more_env: []
                      words: [{<_xfunc>} {<ssh>} {<_scp_local_files>}]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
            (command.ControlFlow keyword:<Id.ControlFlow_Return return> arg_word:{<0>})
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.Simple
      blame_tok: <complete>
      more_env: []
      words: [{<complete>} {<-F>} {<_rsync>} {<-o>} {<nospace>} {<rsync>}]
      redirects: []
      do_fork: T
    )
  ]
  ops: [<Id.Op_DAmp _>]
)