(command.CommandList
  children: [
    (command.ShFunction
      name: _ssh_queries
      body: 
        (command.BraceGroup
          children: [
            (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 <'cipher cipher-auth mac kex key protocol-version'>)} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                    )
                                  ]
                                )
                            )
                          }
                        ]
                      )
                    }
                  spids: [11]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: _ssh_query
      body: 
        (command.BraceGroup
          children: [
            (command.Simple
              words: [
                {
                  (braced_var_sub
                    token: <Id.VSub_Number 1>
                    suffix_op: (suffix_op.Unary op_id:Id.VTest_ColonHyphen arg_word:{<ssh>})
                  )
                }
                {<-Q>}
                {($ Id.VSub_Number '$2')}
              ]
              redirects: [(redir.Redir op:<Id.Redir_Great '2>'> fd:2 arg_word:{</dev/null>})]
            )
          ]
        )
    )
    (command.ShFunction
      name: _ssh_ciphers
      body: 
        (command.BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'ciphers='> (SQ <'$( _ssh_query "$1" cipher )'>)})
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.DBracket
                  expr: (bool_expr.WordTest w:{($ Id.VSub_DollarName '$ciphers')})
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:ciphers)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ <'3des-cbc aes128-cbc aes192-cbc aes256-cbc\n'> 
                            <
'        aes128-ctr aes192-ctr aes256-ctr arcfour128 arcfour256 arcfour\n'
                            > <'        blowfish-cbc cast128-cbc'>
                          )
                        }
                      spids: [85]
                    )
                  ]
                )
              ]
            )
            (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 ($ Id.VSub_DollarName '$ciphers'))} {<-->} 
                                      {(DQ ($ Id.VSub_DollarName '$cur'))}
                                    )
                                  ]
                                )
                            )
                          }
                        ]
                      )
                    }
                  spids: [93]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: _ssh_macs
      body: 
        (command.BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'macs='> (SQ <'$( _ssh_query "$1" mac )'>)})
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.DBracket
                  expr: (bool_expr.WordTest w:{($ Id.VSub_DollarName '$macs')})
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:macs)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ <'hmac-md5 hmac-sha1 umac-64@openssh.com hmac-ripemd160\n'> 
                            <'        hmac-sha1-96 hmac-md5-96'>
                          )
                        }
                      spids: [142]
                    )
                  ]
                )
              ]
            )
            (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 ($ Id.VSub_DollarName '$macs'))} {<-->} 
                                      {(DQ ($ Id.VSub_DollarName '$cur'))}
                                    )
                                  ]
                                )
                            )
                          }
                        ]
                      )
                    }
                  spids: [149]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: _ssh_options
      body: 
        (command.BraceGroup
          children: [
            (C {<compopt>} {<-o>} {<nospace>})
            (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>} {<-S>} {<Id.Lit_Equals '='>} {<-W>} 
                                      {
                                        (SQ <'AddressFamily BatchMode BindAddress\n'> 
                                          <
'        ChallengeResponseAuthentication CheckHostIP Cipher Ciphers\n'
                                          > <'        ClearAllForwardings Compression CompressionLevel ConnectionAttempts\n'> 
                                          <
'        ConnectTimeout ControlMaster ControlPath ControlPersist DynamicForward\n'
                                          > <'        EnableSSHKeysign EscapeChar ExitOnForwardFailure ForwardAgent\n'> 
                                          <
'        ForwardX11 ForwardX11Timeout ForwardX11Trusted GatewayPorts\n'
                                          > <'        GlobalKnownHostsFile GSSAPIAuthentication GSSAPIClientIdentity\n'> 
                                          <
'        GSSAPIDelegateCredentials GSSAPIKeyExchange GSSAPIRenewalForcesRekey\n'
                                          > <'        GSSAPIServerIdentity GSSAPITrustDns HashKnownHosts Host\n'> 
                                          <
'        HostbasedAuthentication HostKeyAlgorithms HostKeyAlias HostName\n'
                                          > <'        IdentityFile IdentitiesOnly IPQoS KbdInteractiveDevices KexAlgorithms\n'> 
                                          <'        LocalCommand LocalForward LogLevel MACs\n'> <'        NoHostAuthenticationForLocalhost NumberOfPasswordPrompts\n'> 
                                          <
'        PasswordAuthentication PermitLocalCommand PKCS11Provider Port\n'
                                          > <'        PreferredAuthentications Protocol ProxyCommand PubkeyAuthentication\n'> 
                                          <
'        RekeyLimit RemoteForward RequestTTY RhostsRSAAuthentication\n'
                                          > <'        RSAAuthentication SendEnv ServerAliveCountMax ServerAliveInterval\n'> 
                                          <
'        SmartcardDevice StrictHostKeyChecking TCPKeepAlive Tunnel TunnelDevice\n'
                                          > <'        UsePrivilegedPort User UserKnownHostsFile VerifyHostKeyDNS\n'> 
                                          <'        VisualHostKey XAuthLocation'>
                                        )
                                      } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                    )
                                  ]
                                )
                            )
                          }
                        ]
                      )
                    }
                  spids: [189]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: _ssh_suboption
      body: 
        (command.BraceGroup
          children: [
            (C {<local>} 
              {<Id.Lit_VarLike 'prev='> 
                (braced_var_sub
                  token: <Id.VSub_Number 1>
                  suffix_op: (suffix_op.Unary op_id:Id.VOp1_DPercent arg_word:{<'=*'>})
                )
              } 
              {<Id.Lit_VarLike 'cur='> 
                (braced_var_sub
                  token: <Id.VSub_Number 1>
                  suffix_op: (suffix_op.Unary op_id:Id.VOp1_Pound arg_word:{<'*='>})
                )
              }
            )
            (command.Case
              to_match: {($ Id.VSub_DollarName '$prev')}
              arms: [
                (case_arm
                  pat_list: [
                    {<BatchMode>}
                    {<ChallengeResponseAuthentication>}
                    {<CheckHostIP>}
                    {<ClearAllForwardings>}
                    {<ControlPersist>}
                    {<Compression>}
                    {<EnableSSHKeysign>}
                    {<ExitOnForwardFailure>}
                    {<ForwardAgent>}
                    {<ForwardX11>}
                    {<ForwardX11Trusted>}
                    {<GatewayPorts>}
                    {<GSSAPIAuthentication>}
                    {<GSSAPIKeyExchange>}
                    {<GSSAPIDelegateCredentials>}
                    {<GSSAPIRenewalForcesRekey>}
                    {<GSSAPITrustDns>}
                    {<HashKnownHosts>}
                    {<HostbasedAuthentication>}
                    {<IdentitiesOnly>}
                    {<KbdInteractiveAuthentication>}
                    {<KbdInteractiveDevices>}
                    {<NoHostAuthenticationForLocalhost>}
                    {<PasswordAuthentication>}
                    {<PubkeyAuthentication>}
                    {<RhostsRSAAuthentication>}
                    {<RSAAuthentication>}
                    {<StrictHostKeyChecking>}
                    {<TCPKeepAlive>}
                    {<UsePrivilegedPort>}
                    {<VerifyHostKeyDNS>}
                    {<VisualHostKey>}
                  ]
                  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 <'yes no'>)} {<-->} 
                                              {(DQ ($ Id.VSub_DollarName '$cur'))}
                                            )
                                          ]
                                        )
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [375]
                        )
                      ]
                    )
                  ]
                  spids: [289 372 399 -1]
                )
                (case_arm
                  pat_list: [{<AddressFamily>}]
                  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 <'any inet inet6'>)} {<-->} 
                                              {(DQ ($ Id.VSub_DollarName '$cur'))}
                                            )
                                          ]
                                        )
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [406]
                        )
                      ]
                    )
                  ]
                  spids: [402 403 430 -1]
                )
                (case_arm
                  pat_list: [{<BindAddress>}]
                  action: [(C {<_ip_addresses>})]
                  spids: [433 434 440 -1]
                )
                (case_arm
                  pat_list: [{<Cipher>}]
                  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 <'blowfish des 3des'>)} {<-->} 
                                              {(DQ ($ Id.VSub_DollarName '$cur'))}
                                            )
                                          ]
                                        )
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [447]
                        )
                      ]
                    )
                  ]
                  spids: [443 444 471 -1]
                )
                (case_arm
                  pat_list: [{<IPQoS>}]
                  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 <'af1{1..4} af2{2..3} af3{1..3} af4{1..3}\n'> 
                                                  <
'                cs{0..7} ef lowdelay throughput reliability'
                                                  >
                                                )
                                              } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                            )
                                          ]
                                        )
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [478]
                        )
                      ]
                    )
                  ]
                  spids: [474 475 503 -1]
                )
                (case_arm
                  pat_list: [{<HostbasedKeyTypes>} {<HostKeyAlgorithms>}]
                  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 <'$( _ssh_query "$2" key )'>)} 
                                              {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                            )
                                          ]
                                        )
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [512]
                        )
                      ]
                    )
                  ]
                  spids: [506 509 536 -1]
                )
                (case_arm
                  pat_list: [{<KexAlgorithms>}]
                  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 <'$( _ssh_query "$2" kex )'>)} 
                                              {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                            )
                                          ]
                                        )
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [543]
                        )
                      ]
                    )
                  ]
                  spids: [539 540 567 -1]
                )
                (case_arm
                  pat_list: [{<Protocol>}]
                  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 2 1,2 2,1'>)} {<-->} 
                                              {(DQ ($ Id.VSub_DollarName '$cur'))}
                                            )
                                          ]
                                        )
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [574]
                        )
                      ]
                    )
                  ]
                  spids: [570 571 598 -1]
                )
                (case_arm
                  pat_list: [{<RequestTTY>}]
                  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 <'no yes force auto'>)} {<-->} 
                                              {(DQ ($ Id.VSub_DollarName '$cur'))}
                                            )
                                          ]
                                        )
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [605]
                        )
                      ]
                    )
                  ]
                  spids: [601 602 629 -1]
                )
                (case_arm
                  pat_list: [{<Tunnel>}]
                  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 <'yes no point-to-point ethernet'>)} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                            )
                                          ]
                                        )
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [636]
                        )
                      ]
                    )
                  ]
                  spids: [632 633 662 -1]
                )
                (case_arm
                  pat_list: [{<PreferredAuthentications>}]
                  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 <'gssapi-with-mic host-based publickey\n'> 
                                                  <'                keyboard-interactive password'>
                                                )
                                              } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                            )
                                          ]
                                        )
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [669]
                        )
                      ]
                    )
                  ]
                  spids: [665 666 694 -1]
                )
                (case_arm
                  pat_list: [{<MACs>}]
                  action: [(C {<_ssh_macs>} {(DQ ($ Id.VSub_Number '$2'))})]
                  spids: [697 698 708 -1]
                )
                (case_arm
                  pat_list: [{<Ciphers>}]
                  action: [(C {<_ssh_ciphers>} {(DQ ($ Id.VSub_Number '$2'))})]
                  spids: [711 712 722 -1]
                )
              ]
            )
            (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<0>})
          ]
        )
    )
    (command.ShFunction
      name: _ssh_suboption_check
      body: 
        (command.BraceGroup
          children: [
            (C {<local>} 
              {<Id.Lit_VarLike 'cureq='> 
                (command_sub
                  left_token: <Id.Left_Backtick '`'>
                  command_list: 
                    (command.CommandList
                      children: [(C {<_get_cword>} {<Id.Lit_Other ':'> <Id.Lit_Equals '='>})]
                    )
                )
              } 
              {<Id.Lit_VarLike 'preveq='> 
                (command_sub
                  left_token: <Id.Left_Backtick '`'>
                  command_list: 
                    (command.CommandList
                      children: [(C {<_get_pword>} {<Id.Lit_Other ':'> <Id.Lit_Equals '='>})]
                    )
                )
              }
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.LogicalAnd
                              left: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {($ Id.VSub_DollarName '$cureq')}
                                  right: 
                                    {<Id.Lit_Other '*'> <Id.BoolBinary_GlobEqual '='> 
                                      <Id.Lit_Other '*'>
                                    }
                                )
                              right: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {($ Id.VSub_DollarName '$preveq')}
                                  right: {<Id.BoolUnary_o -o>}
                                )
                            )
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                  action: [
                    (C {<_ssh_suboption>} {($ Id.VSub_DollarName '$cureq')} 
                      {(DQ ($ Id.VSub_Number '$1'))}
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {($ Id.VSub_QMark '$?')}
                    )
                  ]
                  spids: [778 801]
                )
              ]
            )
            (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<1>})
          ]
        )
    )
    (command.AndOr
      ops: [Id.Op_DAmp Id.Op_DAmp]
      children: [
        (command.ShFunction
          name: _ssh
          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>} {<configfile>})
                (C {<local>} {<-a>} {<config>})
                (command.AndOr
                  ops: [Id.Op_DAmp]
                  children: [
                    (C {<_ssh_suboption_check>} {(DQ ($ Id.VSub_Number '$1'))})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                )
                (command.Case
                  to_match: {($ Id.VSub_DollarName '$prev')}
                  arms: [
                    (case_arm
                      pat_list: [{<-F>} {<-i>} {<-S>}]
                      action: [
                        (C {<_filedir>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [892 897 908 -1]
                    )
                    (case_arm
                      pat_list: [{<-c>}]
                      action: [
                        (C {<_ssh_ciphers>} {(DQ ($ Id.VSub_Number '$1'))})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [911 912 927 -1]
                    )
                    (case_arm
                      pat_list: [{<-m>}]
                      action: [
                        (C {<_ssh_macs>} {(DQ ($ Id.VSub_Number '$1'))})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [930 931 946 -1]
                    )
                    (case_arm
                      pat_list: [{<-l>}]
                      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>} {<-u>} {<-->} 
                                                  {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [953]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [949 950 978 -1]
                    )
                    (case_arm
                      pat_list: [{<-O>}]
                      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 <'check forward exit stop'>)} 
                                                  {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [985]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [981 982 1014 -1]
                    )
                    (case_arm
                      pat_list: [{<-o>}]
                      action: [
                        (C {<_ssh_options>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1017 1018 1029 -1]
                    )
                    (case_arm
                      pat_list: [{<-Q>}]
                      action: [
                        (C {<_ssh_queries>} {(DQ ($ Id.VSub_Number '$1'))})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1032 1033 1048 -1]
                    )
                    (case_arm
                      pat_list: [{<-w>}]
                      action: [
                        (C {<_available_interfaces>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1051 1052 1063 -1]
                    )
                    (case_arm
                      pat_list: [{<-b>}]
                      action: [
                        (C {<_ip_addresses>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1066 1067 1078 -1]
                    )
                    (case_arm
                      pat_list: [{<-D>} {<-e>} {<-I>} {<-L>} {<-p>} {<-R>} {<-W>}]
                      action: [
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1081 1094 1102 -1]
                    )
                  ]
                )
                (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: {<-F> <Id.Lit_Other '*'>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                      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.VOp1_Pound arg_word:{<-F>})
                                  )
                                }
                              spids: [1128]
                            )
                          ]
                        )
                        (C {<_filedir>})
                        (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: [
                                      {
                                        (DQ 
                                          (braced_var_sub
                                            token: <Id.VSub_Name COMPREPLY>
                                            bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                            suffix_op: 
                                              (suffix_op.PatSub
                                                pat: {}
                                                replace: {<-F>}
                                                replace_mode: Id.Lit_Pound
                                              )
                                          )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1143]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:cur)
                              op: assign_op.Equal
                              rhs: {<-F> ($ Id.VSub_DollarName '$cur')}
                              spids: [1162]
                            )
                          ]
                        )
                      ]
                      spids: [1109 1125]
                    )
                    (if_arm
                      cond: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                  right: {<-> <Id.Lit_Other '*'>}
                                )
                            )
                          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 <'$( _parse_usage "$1" )'>)} 
                                                  {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1189]
                            )
                          ]
                        )
                      ]
                      spids: [1170 1186]
                    )
                  ]
                  else_action: [
                    (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:configfile)
                                                  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: [1286]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [1267 1283]
                                        )
                                      ]
                                      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:configfile)
                                                  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: [1316]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <Id.ControlFlow_Break break>
                                    )
                                  ]
                                  spids: [1250 1264]
                                )
                              ]
                            )
                            (C {<shift>})
                          ]
                        )
                    )
                    (C {<_known_hosts_real>} {<-a>} {<-F>} {(DQ ($ Id.VSub_DollarName '$configfile'))} 
                      {(DQ ($ Id.VSub_DollarName '$cur'))}
                    )
                    (C {<local>} {<args>})
                    (C {<_count_args>})
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_gt
                                      left: {($ Id.VSub_DollarName '$args')}
                                      right: {<1>}
                                    )
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                          action: [
                            (C {<compopt>} {<-o>} {<filenames>})
                            (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>} {<-c>} {<-->} 
                                                      {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [1390]
                                )
                              ]
                            )
                          ]
                          spids: [1367 1380]
                        )
                      ]
                    )
                  ]
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<0>}
                )
              ]
            )
        )
        (C {<shopt>} {<-u>} {<hostcomplete>})
        (C {<complete>} {<-F>} {<_ssh>} {<ssh>} {<slogin>} {<autossh>})
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp Id.Op_DAmp]
      children: [
        (command.ShFunction
          name: _sftp
          body: 
            (command.BraceGroup
              children: [
                (C {<local>} {<cur>} {<prev>} {<words>} {<cword>})
                (command.AndOr
                  ops: [Id.Op_DPipe]
                  children: [
                    (C {<_init_completion>})
                    (command.ControlFlow token:<Id.ControlFlow_Return return>)
                  ]
                )
                (C {<local>} {<configfile>})
                (command.AndOr
                  ops: [Id.Op_DAmp]
                  children: [
                    (C {<_ssh_suboption_check>})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                )
                (command.Case
                  to_match: {($ Id.VSub_DollarName '$prev')}
                  arms: [
                    (case_arm
                      pat_list: [{<-b>} {<-F>} {<-i>}]
                      action: [
                        (C {<_filedir>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1501 1506 1517 -1]
                    )
                    (case_arm
                      pat_list: [{<-o>}]
                      action: [
                        (C {<_ssh_options>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1520 1521 1532 -1]
                    )
                    (case_arm
                      pat_list: [{<-c>}]
                      action: [
                        (C {<_ssh_ciphers>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1535 1536 1547 -1]
                    )
                    (case_arm
                      pat_list: [{<-S>}]
                      action: [
                        (C {<_command>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1550 1551 1562 -1]
                    )
                    (case_arm
                      pat_list: [{<-B>} {<-D>} {<-l>} {<-P>} {<-R>} {<-s>}]
                      action: [
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1565 1576 1584 -1]
                    )
                  ]
                )
                (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: {<-F> <Id.Lit_Other '*'>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                      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.VOp1_Pound arg_word:{<-F>})
                                  )
                                }
                              spids: [1610]
                            )
                          ]
                        )
                        (C {<_filedir>})
                        (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: [
                                      {
                                        (DQ 
                                          (braced_var_sub
                                            token: <Id.VSub_Name COMPREPLY>
                                            bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                            suffix_op: 
                                              (suffix_op.PatSub
                                                pat: {}
                                                replace: {<-F>}
                                                replace_mode: Id.Lit_Pound
                                              )
                                          )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1625]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:cur)
                              op: assign_op.Equal
                              rhs: {<-F> ($ Id.VSub_DollarName '$cur')}
                              spids: [1644]
                            )
                          ]
                        )
                      ]
                      spids: [1591 1607]
                    )
                    (if_arm
                      cond: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                  right: {<-> <Id.Lit_Other '*'>}
                                )
                            )
                          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 <'$( _parse_usage "$1" )'>)} 
                                                  {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1671]
                            )
                          ]
                        )
                      ]
                      spids: [1652 1668]
                    )
                  ]
                  else_action: [
                    (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:configfile)
                                                  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: [1768]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [1749 1765]
                                        )
                                      ]
                                      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:configfile)
                                                  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: [1798]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <Id.ControlFlow_Break break>
                                    )
                                  ]
                                  spids: [1732 1746]
                                )
                              ]
                            )
                            (C {<shift>})
                          ]
                        )
                    )
                    (C {<_known_hosts_real>} {<-a>} {<-F>} {(DQ ($ Id.VSub_DollarName '$configfile'))} 
                      {(DQ ($ Id.VSub_DollarName '$cur'))}
                    )
                  ]
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<0>}
                )
              ]
            )
        )
        (C {<shopt>} {<-u>} {<hostcomplete>})
        (C {<complete>} {<-F>} {<_sftp>} {<sftp>})
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:_scp_path_esc)
          op: assign_op.Equal
          rhs: {(SQ <'[][(){}<>",:;^&!$=?`|\\\\'>) (DQ <"'">) (SQ <'[:space:]]'>)}
          spids: [1872]
        )
      ]
    )
    (command.ShFunction
      name: _scp_remote_files
      body: 
        (command.BraceGroup
          children: [
            (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:cur)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <Id.VSub_Name cur>
                        suffix_op: 
                          (suffix_op.PatSub
                            pat: {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\\\'>) <':'>}
                            replace: {<':'>}
                            replace_mode: Id.Undefined_Tok
                          )
                      )
                    }
                  spids: [1910]
                )
              ]
            )
            (C {<local>} 
              {<Id.Lit_VarLike 'userhost='> 
                (braced_var_sub
                  token: <Id.VSub_Name cur>
                  suffix_op: 
                    (suffix_op.Unary
                      op_id: Id.VOp1_DPercent
                      arg_word: 
                        {<'?('> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\\\'>) <'):*'>}
                    )
                )
              }
            )
            (C {<local>} 
              {<Id.Lit_VarLike 'path='> 
                (braced_var_sub
                  token: <Id.VSub_Name cur>
                  suffix_op: (suffix_op.Unary op_id:Id.VOp1_Pound arg_word:{<'*:'>})
                )
              }
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:path)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        command_list: 
                          (command.CommandList
                            children: [
                              (command.Simple
                                words: [
                                  {<sed>}
                                  {<-e>}
                                  {(SQ <'s/\\\\\\\\\\\\\\('>) ($ Id.VSub_DollarName '$_scp_path_esc') 
                                    (SQ <'\\)/\\\\\\1/g'>)
                                  }
                                ]
                                redirects: [
                                  (redir.Redir
                                    op: <Id.Redir_TLess '<<<'>
                                    fd: -1
                                    arg_word: {(DQ ($ Id.VSub_DollarName '$path'))}
                                  )
                                ]
                              )
                            ]
                          )
                      )
                    }
                  spids: [1949]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_z
                              child: {($ Id.VSub_DollarName '$path')}
                            )
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:path)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (command.Simple
                                        words: [
                                          {<ssh>}
                                          {<-o>}
                                          {(SQ <'Batchmode yes'>)}
                                          {($ Id.VSub_DollarName '$userhost')}
                                          {<pwd>}
                                        ]
                                        redirects: [
                                          (redir.Redir
                                            op: <Id.Redir_Great '2>'>
                                            fd: 2
                                            arg_word: {</dev/null>}
                                          )
                                        ]
                                      )
                                    ]
                                  )
                              )
                            }
                          spids: [1991]
                        )
                      ]
                    )
                  ]
                  spids: [1977 1988]
                )
              ]
            )
            (C {<local>} {<files>})
            (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: {<Id.BoolUnary_d -d>}
                            )
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:files)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (command.Pipeline
                                        children: [
                                          (command.Simple
                                            words: [
                                              {<ssh>}
                                              {<-o>}
                                              {(SQ <'Batchmode yes'>)}
                                              {($ Id.VSub_DollarName '$userhost')}
                                              {<command>}
                                              {<ls>}
                                              {<-aF1dL>}
                                              {(DQ ($ Id.VSub_DollarName '$path') <'*'>)}
                                            ]
                                            redirects: [
                                              (redir.Redir
                                                op: <Id.Redir_Great '2>'>
                                                fd: 2
                                                arg_word: {</dev/null>}
                                              )
                                            ]
                                          )
                                          (C {<sed>} {<-e>} 
                                            {(SQ <s/>) ($ Id.VSub_DollarName '$_scp_path_esc') 
                                              (SQ <'/\\\\\\\\\\\\&/g'>)
                                            } {<-e>} {(SQ <'/[^\\/]$/d'>)}
                                          )
                                        ]
                                        negated: F
                                      )
                                    ]
                                  )
                              )
                            }
                          spids: [2039]
                        )
                      ]
                    )
                  ]
                  spids: [2019 2032]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:files)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            command_list: 
                              (command.CommandList
                                children: [
                                  (command.Pipeline
                                    children: [
                                      (command.Simple
                                        words: [
                                          {<ssh>}
                                          {<-o>}
                                          {(SQ <'Batchmode yes'>)}
                                          {($ Id.VSub_DollarName '$userhost')}
                                          {<command>}
                                          {<ls>}
                                          {<-aF1dL>}
                                          {(DQ ($ Id.VSub_DollarName '$path') <'*'>)}
                                        ]
                                        redirects: [
                                          (redir.Redir
                                            op: <Id.Redir_Great '2>'>
                                            fd: 2
                                            arg_word: {</dev/null>}
                                          )
                                        ]
                                      )
                                      (C {<sed>} {<-e>} 
                                        {(SQ <s/>) ($ Id.VSub_DollarName '$_scp_path_esc') 
                                          (SQ <'/\\\\\\\\\\\\&/g'>)
                                        } {<-e>} {(SQ <'s/[*@|=]$//g'>)} {<-e>} {(SQ <'s/[^\\/]$/& /g'>)}
                                      )
                                    ]
                                    negated: F
                                  )
                                ]
                              )
                          )
                        }
                      spids: [2104]
                    )
                  ]
                )
              ]
            )
            (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: [{($ Id.VSub_DollarName '$files')}]
                      )
                    }
                  spids: [2169]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: _scp_local_files
      body: 
        (command.BraceGroup
          children: [
            (C {<local>} 
              {<Id.Lit_VarLike 'IFS='> 
                (single_quoted
                  left: <Id.Left_SingleQuoteC "$'">
                  tokens: [<Id.Char_OneChar '\\n'>]
                )
              }
            )
            (C {<local>} {<Id.Lit_VarLike 'dirsonly='> <false>})
            (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: {<Id.BoolUnary_d -d>}
                            )
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:dirsonly)
                          op: assign_op.Equal
                          rhs: {<true>}
                          spids: [2229]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                  spids: [2213 2226]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {($ Id.VSub_DollarName '$dirsonly')})
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                  action: [
                    (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: [
                                            (command.Pipeline
                                              children: [
                                                (command.Simple
                                                  words: [
                                                    {<command>}
                                                    {<ls>}
                                                    {<-aF1dL>}
                                                    {($ Id.VSub_DollarName '$cur') <Id.Lit_Star '*'>}
                                                  ]
                                                  redirects: [
                                                    (redir.Redir
                                                      op: <Id.Redir_Great '2>'>
                                                      fd: 2
                                                      arg_word: {</dev/null>}
                                                    )
                                                  ]
                                                )
                                                (C {<sed>} {<-e>} 
                                                  {
                                                    (DQ <s/> ($ Id.VSub_DollarName '$_scp_path_esc') 
                                                      </> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\\\'>) 
                                                      (word_part.EscapedLiteral
                                                        token: <Id.Lit_EscapedChar '\\\\'>
                                                      ) <'&/g'>
                                                    )
                                                  } {<-e>} {(SQ <'/[^\\/]$/d'>)} {<-e>} {(DQ <'s/^/'> ($ Id.VSub_Number '$1') </>)}
                                                )
                                              ]
                                              negated: F
                                            )
                                          ]
                                        )
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [2249]
                        )
                      ]
                    )
                  ]
                  spids: [2240 2246]
                )
              ]
              else_action: [
                (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: [
                                        (command.Pipeline
                                          children: [
                                            (command.Simple
                                              words: [
                                                {<command>}
                                                {<ls>}
                                                {<-aF1dL>}
                                                {($ Id.VSub_DollarName '$cur') <Id.Lit_Star '*'>}
                                              ]
                                              redirects: [
                                                (redir.Redir
                                                  op: <Id.Redir_Great '2>'>
                                                  fd: 2
                                                  arg_word: {</dev/null>}
                                                )
                                              ]
                                            )
                                            (C {<sed>} {<-e>} 
                                              {
                                                (DQ <s/> ($ Id.VSub_DollarName '$_scp_path_esc') </> 
                                                  (word_part.EscapedLiteral
                                                    token: <Id.Lit_EscapedChar '\\\\'>
                                                  ) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\\\'>) <'&/g'>
                                                )
                                              } {<-e>} {(SQ <'s/[*@|=]$//g'>)} {<-e>} {(SQ <'s/[^\\/]$/& /g'>)} {<-e>} 
                                              {(DQ <'s/^/'> ($ Id.VSub_Number '$1') </>)}
                                            )
                                          ]
                                          negated: F
                                        )
                                      ]
                                    )
                                )
                              }
                            ]
                          )
                        }
                      spids: [2304]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (command.ShFunction
          name: _scp
          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>} {<configfile>} {<prefix>})
                (command.AndOr
                  ops: [Id.Op_DAmp]
                  children: [
                    (C {<_ssh_suboption_check>})
                    (command.BraceGroup
                      children: [
                        (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: [
                                      {
                                        (DQ 
                                          (braced_var_sub
                                            token: <Id.VSub_Name COMPREPLY>
                                            bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                            suffix_op: 
                                              (suffix_op.PatSub
                                                pat: {}
                                                replace: {<' '>}
                                                replace_mode: Id.Lit_Percent
                                              )
                                          )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [2420]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                    )
                  ]
                )
                (command.Case
                  to_match: {($ Id.VSub_DollarName '$prev')}
                  arms: [
                    (case_arm
                      pat_list: [{<-l>} {<-P>}]
                      action: [
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [2455 2458 2466 -1]
                    )
                    (case_arm
                      pat_list: [{<-F>} {<-i>}]
                      action: [
                        (C {<_filedir>})
                        (C {<compopt>} {<Id.Lit_Other '+'> <o>} {<nospace>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [2469 2472 2491 -1]
                    )
                    (case_arm
                      pat_list: [{<-c>}]
                      action: [
                        (C {<_ssh_ciphers>})
                        (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: [
                                      {
                                        (DQ 
                                          (braced_var_sub
                                            token: <Id.VSub_Name COMPREPLY>
                                            bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                            suffix_op: 
                                              (suffix_op.PatSub
                                                pat: {}
                                                replace: {<' '>}
                                                replace_mode: Id.Lit_Percent
                                              )
                                          )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [2501]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [2494 2495 2525 -1]
                    )
                    (case_arm
                      pat_list: [{<-o>}]
                      action: [
                        (C {<_ssh_options>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [2528 2529 2540 -1]
                    )
                    (case_arm
                      pat_list: [{<-S>}]
                      action: [
                        (C {<_command>})
                        (C {<compopt>} {<Id.Lit_Other '+'> <o>} {<nospace>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [2543 2544 2563 -1]
                    )
                  ]
                )
                (command.AndOr
                  ops: [Id.Op_DPipe]
                  children: [
                    (C {<_expand>})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                )
                (command.Case
                  to_match: {($ Id.VSub_DollarName '$cur')}
                  arms: [
                    (case_arm
                      pat_list: [
                        {
                          (word_part.ExtGlob
                            op: <Id.ExtGlob_Bang '!('>
                            arms: [{<Id.Lit_Other '*'> <':'> <Id.Lit_Other '*'>}]
                          ) </> <Id.Lit_Star '*'>
                        }
                        {<Id.Lit_LBracket '['> <.> <Id.Lit_TildeLike '~'> <Id.Lit_RBracket ']'> 
                          <Id.Lit_Star '*'>
                        }
                      ]
                      spids: [2587 2600 2602 -1]
                    )
                    (case_arm
                      pat_list: [{<Id.Lit_Star '*'> <Id.Lit_Other ':'> <Id.Lit_Star '*'>}]
                      action: [
                        (command.Sentence
                          child: (C {<_scp_remote_files>})
                          terminator: <Id.Op_Semi _>
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [2608 2611 2621 -1]
                    )
                  ]
                )
                (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: {<-F> <Id.Lit_Other '*'>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                      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.VOp1_Pound arg_word:{<-F>})
                                  )
                                }
                              spids: [2647]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:prefix)
                              op: assign_op.Equal
                              rhs: {<-F>}
                              spids: [2655]
                            )
                          ]
                        )
                      ]
                      spids: [2628 2644]
                    )
                  ]
                  else_action: [
                    (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:configfile)
                                                  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: [2732]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [2713 2729]
                                        )
                                      ]
                                      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:configfile)
                                                  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: [2762]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <Id.ControlFlow_Break break>
                                    )
                                  ]
                                  spids: [2696 2710]
                                )
                              ]
                            )
                            (C {<shift>})
                          ]
                        )
                    )
                    (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 <'$( _parse_usage "${words[0]}" )'>)} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [2802]
                                )
                              ]
                            )
                            (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: [
                                          {
                                            (DQ 
                                              (braced_var_sub
                                                token: <Id.VSub_Name COMPREPLY>
                                                bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                                suffix_op: 
                                                  (suffix_op.PatSub
                                                    pat: {}
                                                    replace: {<' '>}
                                                    replace_mode: Id.Lit_Percent
                                                  )
                                              )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [2828]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                              arg_word: {<0>}
                            )
                          ]
                          spids: [2797 2799 2852 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<Id.Lit_Star '*'> </> <Id.Lit_Star '*'>}
                            {<Id.Lit_LBracket '['> <.> <Id.Lit_TildeLike '~'> <Id.Lit_RBracket ']'> 
                              <Id.Lit_Star '*'>
                            }
                          ]
                          spids: [2855 2864 2871 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [
                            (C {<_known_hosts_real>} {<-c>} {<-a>} {<-F>} 
                              {(DQ ($ Id.VSub_DollarName '$configfile'))} {(DQ ($ Id.VSub_DollarName '$cur'))}
                            )
                          ]
                          spids: [2874 2875 2895 -1]
                        )
                      ]
                    )
                  ]
                )
                (C {<_scp_local_files>} {(DQ ($ Id.VSub_DollarName '$prefix'))})
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<0>}
                )
              ]
            )
        )
        (C {<complete>} {<-F>} {<_scp>} {<-o>} {<nospace>} {<scp>})
      ]
    )
  ]
)