(command.CommandList
  children: [
    (command.Simple
      blame_tok: <Id.Lit_Colon ':'>
      more_env: []
      words: [{<Id.Lit_Colon ':'>} {<copy>} {<http>} {<url>} {<Id.KW_Data data>}]
      redirects: []
      do_fork: T
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'command='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'command='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'command='> name:command)
          op: assign_op.Equal
          rhs: {<hurl>}
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'agent='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'agent='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'agent='> name:agent)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName command) <'/2009-01-20 (AT&T Research)'>)}
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'authorize='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'authorize='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'authorize='> name:authorize)
          op: assign_op.Equal
          rhs: (rhs_word__Empty)
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'verbose='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'verbose='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'verbose='> name:verbose)
          op: assign_op.Equal
          rhs: {<0>}
        )
      ]
      redirects: []
    )
    (command.Case
      case_kw: <Id.KW_Case case>
      to_match: 
        (case_arg.Word
          w: 
            {
              (CommandSub
                left_token: <Id.Left_Backtick '`'>
                child: 
                  (command.Subshell
                    left: <Id.Op_LParen _>
                    child: 
                      (command.CommandList
                        children: [
                          (command.Sentence
                            child: 
                              (command.Simple
                                blame_tok: <getopts>
                                more_env: []
                                words: [{<getopts>} {(SQ <'[-][123:xyz]'>)} {<opt>} {<--xyz>}]
                                redirects: []
                                do_fork: T
                              )
                            terminator: <Id.Op_Semi _>
                          )
                          (command.Simple
                            blame_tok: <echo>
                            more_env: []
                            words: [{<echo>} {<0> ($ Id.VSub_DollarName opt)}]
                            redirects: []
                            do_fork: T
                          )
                        ]
                      )
                    right: <Id.Right_Subshell _>
                    redirects: [
                      (Redir
                        op: <Id.Redir_Great '2>'>
                        loc: (redir_loc.Fd fd:2)
                        arg: {<'/dev/null'>}
                      )
                    ]
                  )
                right: <Id.Backtick_Right '`'>
              )
            }
        )
      arms_start: <Id.KW_In in>
      arms: [
        (CaseArm
          left: <0123>
          pattern: (pat.Words words:[{<0123>}])
          middle: <Id.Right_CasePat _>
          action: [
            (command.ShAssignment
              left: <Id.Lit_VarLike 'ARGV0='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'ARGV0='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'ARGV0='> name:ARGV0)
                  op: assign_op.Equal
                  rhs: {(DQ <'-a '> ($ Id.VSub_DollarName command))}
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'USAGE='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'USAGE='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'USAGE='> name:USAGE)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (SingleQuoted
                        left: <Id.Left_DollarSingleQuote '$\''>
                        tokens: [
                          <Id.Char_Literals '\n'>
                          <Id.Char_Literals '[-?\n'>
                          <Id.Char_Literals '@(#)$Id: hurl (AT&T Research) 2009-01-20 $\n'>
                          <Id.Char_Literals ']\n'>
                        ]
                        right: <Id.Right_SingleQuote '\''>
                      ) ($ Id.VSub_DollarName USAGE_LICENSE) 
                      (SingleQuoted
                        left: <Id.Left_DollarSingleQuote '$\''>
                        tokens: [
                          <Id.Char_Literals '\n'>
                          <Id.Char_Literals '[+NAME?hurl - copy http url data]\n'>
                          <Id.Char_Literals '[+DESCRIPTION?'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals hurl>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' copies the data for the '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals http>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals url>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals ' operand\n'>
                          <Id.Char_Literals '\tto the standard output. The '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals url>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals ' must be of the form\n'>
                          <Id.Char_Literals '\t'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '[http://]]'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals host>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals '['>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ':'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals port>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals ']]'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '/'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals path>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals '. The default\n'>
                          <Id.Char_Literals '\t'>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals port>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals ' is '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals 80>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '.]\n'>
                          <Id.Char_Literals '[+?'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals hurl>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' is a shell script that attempts to access the '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals url>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals ' by\n'>
                          <Id.Char_Literals '\tthese methods:]{\n'>
                          <Id.Char_Literals '\t[+/dev/tcp/'>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals host>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '/80'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '?Supported by '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ksh>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1) and recent\n'>
                          <Id.Char_Literals '\t\t'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals bash>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1).]\n'>
                          <Id.Char_Literals '\t[+wget -nv -O - '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals url>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals '?]\n'>
                          <Id.Char_Literals '\t[+lynx -source '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals url>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals '?]\n'>
                          <Id.Char_Literals '\t[+curl -s -L -o - '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals url>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals '?]\n'>
                          <Id.Char_Literals '}\n'>
                          <Id.Char_Literals 
'[a:authorize?The url authorization user name and password, separated\n'
                          >
                          <Id.Char_Literals '\tby '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ':'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' (one colon character.)]:[user::password]\n'>
                          <Id.Char_Literals '[s:size?Terminate the data transmission after '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals bytes>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals ' have been\n'>
                          <Id.Char_Literals '\ttransferred.]:[bytes]\n'>
                          <Id.Char_Literals '[v:verbose?Verbose trace.]\n'>
                          <Id.Char_Literals '\n'>
                          <Id.Char_Literals 'url\n'>
                          <Id.Char_Literals '\n'>
                          <Id.Char_Literals '[+SEE ALSO?'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals curl>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1), '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals lynx>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1), '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals wget>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1)]\n'>
                        ]
                        right: <Id.Right_SingleQuote '\''>
                      )
                    }
                )
              ]
              redirects: []
            )
          ]
          right: <Id.Op_DSemi _>
        )
        (CaseArm
          left: <Id.Lit_Star '*'>
          pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
          middle: <Id.Right_CasePat _>
          action: [
            (command.ShAssignment
              left: <Id.Lit_VarLike 'ARGV0='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'ARGV0='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'ARGV0='> name:ARGV0)
                  op: assign_op.Equal
                  rhs: {(DQ )}
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'USAGE='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'USAGE='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'USAGE='> name:USAGE)
                  op: assign_op.Equal
                  rhs: {(DQ <'a:v'>)}
                )
              ]
              redirects: []
            )
          ]
          right: <Id.Op_DSemi _>
        )
      ]
      arms_end: <Id.KW_Esac esac>
      redirects: []
    )
    (command.ShFunction
      name_tok: <usage>
      name: usage
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              left: <Id.Lit_VarLike 'OPTIND='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'OPTIND='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'OPTIND='> name:OPTIND)
                  op: assign_op.Equal
                  rhs: {<0>}
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <getopts>
              more_env: []
              words: [
                {<getopts>}
                {($ Id.VSub_DollarName ARGV0)}
                {(DQ ($ Id.VSub_DollarName USAGE))}
                {<OPT>}
                {(SQ <'-?'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.ControlFlow keyword:<Id.ControlFlow_Exit exit> arg_word:{<2>})
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.Simple
      blame_tok: <integer>
      more_env: []
      words: [
        {<integer>}
        {<Id.Lit_VarLike 'limit='> <0>}
        {<Id.Lit_VarLike 'total='> <0>}
        {<Id.Lit_VarLike 'block='> <8> <Id.Lit_Star '*'> <1024>}
      ]
      redirects: []
      do_fork: T
    )
    (command.WhileUntil
      keyword: <Id.KW_While while>
      cond: 
        (condition.Shell
          commands: [
            (command.Simple
              blame_tok: <getopts>
              more_env: []
              words: [
                {<getopts>}
                {($ Id.VSub_DollarName ARGV0)}
                {(DQ ($ Id.VSub_DollarName USAGE))}
                {<OPT>}
              ]
              redirects: []
              do_fork: T
            )
          ]
        )
      body: 
        (command.DoGroup
          left: <Id.KW_Do do>
          children: [
            (command.Case
              case_kw: <Id.KW_Case case>
              to_match: (case_arg.Word w:{($ Id.VSub_DollarName OPT)})
              arms_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <a>
                  pattern: (pat.Words words:[{<a>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'authorize='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'authorize='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'authorize='> name:authorize)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName OPTARG)}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <s>
                  pattern: (pat.Words words:[{<s>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'limit='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'limit='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'limit='> name:limit)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName OPTARG)}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <v>
                  pattern: (pat.Words words:[{<v>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'verbose='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'verbose='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'verbose='> name:verbose)
                          op: assign_op.Equal
                          rhs: {<1>}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
          ]
          right: <Id.KW_Done done>
        )
      redirects: []
    )
    (command.Simple
      blame_tok: <shift>
      more_env: []
      words: [
        {<shift>}
        {
          (CommandSub
            left_token: <Id.Left_Backtick '`'>
            child: 
              (command.Simple
                blame_tok: <expr>
                more_env: []
                words: [{<expr>} {($ Id.VSub_DollarName OPTIND)} {<->} {<1>}]
                redirects: []
                do_fork: T
              )
            right: <Id.Backtick_Right '`'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'url='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'url='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'url='> name:url)
          op: assign_op.Equal
          rhs: {($ Id.VSub_Number 1)}
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'AUTHORIZE='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'AUTHORIZE='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'AUTHORIZE='> name:AUTHORIZE)
          op: assign_op.Equal
          rhs: (rhs_word__Empty)
        )
      ]
      redirects: []
    )
    (command.Simple
      blame_tok: <exec>
      more_env: []
      words: [{<exec>}]
      redirects: [(Redir op:<Id.Redir_LessAnd '9<&'> loc:(redir_loc.Fd fd:9) arg:{<0>})]
      do_fork: T
    )
    (command.WhileUntil
      keyword: <Id.KW_While while>
      cond: 
        (condition.Shell
          commands: [
            (command.Simple
              blame_tok: <Id.Lit_Colon ':'>
              more_env: []
              words: [{<Id.Lit_Colon ':'>}]
              redirects: []
              do_fork: T
            )
          ]
        )
      body: 
        (command.DoGroup
          left: <Id.KW_Do do>
          children: [
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <test>
                  more_env: []
                  words: [
                    {<test>}
                    {<0>}
                    {<Id.KW_Bang '!'> <Id.Lit_Equals '='>}
                    {($ Id.VSub_DollarName verbose)}
                  ]
                  redirects: []
                  do_fork: T
                )
                (command.Simple
                  blame_tok: <echo>
                  more_env: []
                  words: [
                    {<echo>}
                    {(DQ ($ Id.VSub_DollarName command) <': url='> ($ Id.VSub_DollarName url))}
                  ]
                  redirects: [(Redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
                  do_fork: T
                )
              ]
              ops: [<Id.Op_DAmp _>]
            )
            (command.Case
              case_kw: <Id.KW_Case case>
              to_match: (case_arg.Word w:{($ Id.VSub_DollarName url)})
              arms_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <Id.Lit_Star '*'>
                  pattern: 
                    (pat.Words
                      words: [
                        {<Id.Lit_Star '*'> <Id.Lit_Colon ':'> <'//'> <Id.Lit_Star '*'> <'/'> 
                          <Id.Lit_Star '*'>
                        }
                      ]
                    )
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'prot='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'prot='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'prot='> name:prot)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (BracedVarSub
                                left: <Id.Left_DollarBrace '${'>
                                token: <Id.VSub_Name url>
                                var_name: url
                                suffix_op: 
                                  (suffix_op.Unary
                                    op: <Id.VOp1_DPercent '%%'>
                                    arg_word: {<':'> <Id.Lit_Other '*'>}
                                  )
                                right: <Id.Right_DollarBrace '}'>
                              )
                            }
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'url='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'url='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'url='> name:url)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (BracedVarSub
                                left: <Id.Left_DollarBrace '${'>
                                token: <Id.VSub_Name url>
                                var_name: url
                                suffix_op: 
                                  (suffix_op.Unary
                                    op: <Id.VOp1_Pound '#'>
                                    arg_word: 
                                      {<Id.Lit_Other '*'> <':'> <Id.Lit_Slash '/'> <Id.Lit_Slash '/'>}
                                  )
                                right: <Id.Right_DollarBrace '}'>
                              )
                            }
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <Id.Lit_Star '*'>
                  pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'prot='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'prot='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'prot='> name:prot)
                          op: assign_op.Equal
                          rhs: {<http>}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'host='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'host='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'host='> name:host)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_DollarName url)}
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'path='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'path='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'path='> name:path)
                  op: assign_op.Equal
                  rhs: 
                    {<'/'> 
                      (BracedVarSub
                        left: <Id.Left_DollarBrace '${'>
                        token: <Id.VSub_Name host>
                        var_name: host
                        suffix_op: 
                          (suffix_op.Unary
                            op: <Id.VOp1_Pound '#'>
                            arg_word: {<Id.Lit_Other '*'> <Id.Lit_Slash '/'>}
                          )
                        right: <Id.Right_DollarBrace '}'>
                      )
                    }
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'host='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'host='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'host='> name:host)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (BracedVarSub
                        left: <Id.Left_DollarBrace '${'>
                        token: <Id.VSub_Name host>
                        var_name: host
                        suffix_op: 
                          (suffix_op.Unary
                            op: <Id.VOp1_DPercent '%%'>
                            arg_word: {<Id.Lit_Slash '/'> <Id.Lit_Other '*'>}
                          )
                        right: <Id.Right_DollarBrace '}'>
                      )
                    }
                )
              ]
              redirects: []
            )
            (command.Case
              case_kw: <Id.KW_Case case>
              to_match: (case_arg.Word w:{($ Id.VSub_DollarName host)})
              arms_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <Id.Lit_Star '*'>
                  pattern: 
                    (pat.Words
                      words: [
                        {<Id.Lit_Star '*'> <Id.Lit_Colon ':'> 
                          (word_part.ExtGlob
                            op: <Id.ExtGlob_Plus '+('>
                            arms: [{<'[0-9]'>}]
                            right: <Id.Right_ExtGlob _>
                          )
                        }
                      ]
                    )
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'port='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'port='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'port='> name:port)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (BracedVarSub
                                left: <Id.Left_DollarBrace '${'>
                                token: <Id.VSub_Name host>
                                var_name: host
                                suffix_op: 
                                  (suffix_op.Unary
                                    op: <Id.VOp1_DPound '##'>
                                    arg_word: {<Id.Lit_Other '*'> <':'>}
                                  )
                                right: <Id.Right_DollarBrace '}'>
                              )
                            }
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'host='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'host='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'host='> name:host)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (BracedVarSub
                                left: <Id.Left_DollarBrace '${'>
                                token: <Id.VSub_Name host>
                                var_name: host
                                suffix_op: 
                                  (suffix_op.Unary
                                    op: <Id.VOp1_Percent '%'>
                                    arg_word: {<':'> <Id.Lit_Other '*'>}
                                  )
                                right: <Id.Right_DollarBrace '}'>
                              )
                            }
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <Id.Lit_Star '*'>
                  pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'port='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'port='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'port='> name:port)
                          op: assign_op.Equal
                          rhs: {<80>}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <test>
                  more_env: []
                  words: [
                    {<test>}
                    {<0>}
                    {<Id.KW_Bang '!'> <Id.Lit_Equals '='>}
                    {($ Id.VSub_DollarName verbose)}
                  ]
                  redirects: []
                  do_fork: T
                )
                (command.Simple
                  blame_tok: <echo>
                  more_env: []
                  words: [
                    {<echo>}
                    {
                      (DQ ($ Id.VSub_DollarName command) <': prot='> ($ Id.VSub_DollarName prot) 
                        <' host='> ($ Id.VSub_DollarName host) <' port='> ($ Id.VSub_DollarName port) <' path='> ($ Id.VSub_DollarName path)
                      )
                    }
                  ]
                  redirects: [(Redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
                  do_fork: T
                )
              ]
              ops: [<Id.Op_DAmp _>]
            )
            (command.Case
              case_kw: <Id.KW_Case case>
              to_match: (case_arg.Word w:{($ Id.VSub_DollarName prot)})
              arms_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <http>
                  pattern: (pat.Words words:[{<http>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.If
                      if_kw: <Id.KW_If if>
                      arms: [
                        (IfArm
                          keyword: <Id.KW_If if>
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.AndOr
                                  children: [
                                    (command.Subshell
                                      left: <Id.Op_LParen _>
                                      child: 
                                        (command.AndOr
                                          children: [
                                            (command.Simple
                                              blame_tok: <eval>
                                              more_env: []
                                              words: [{<eval>} {(DQ <'exec >'>)}]
                                              redirects: []
                                              do_fork: T
                                            )
                                            (command.ControlFlow
                                              keyword: <Id.ControlFlow_Exit exit>
                                              arg_word: {<0>}
                                            )
                                          ]
                                          ops: [<Id.Op_DPipe _>]
                                        )
                                      right: <Id.Right_Subshell _>
                                      redirects: [
                                        (Redir
                                          op: <Id.Redir_Great '2>'>
                                          loc: (redir_loc.Fd fd:2)
                                          arg: {<'/dev/null'>}
                                        )
                                      ]
                                    )
                                    (command.Simple
                                      blame_tok: <eval>
                                      more_env: []
                                      words: [
                                        {<eval>}
                                        {
                                          (DQ <'exec 8<> /dev/tcp/'> 
                                            (word_part.EscapedLiteral
                                              token: <Id.Lit_EscapedChar '\\$'>
                                              ch: '$'
                                            ) <'host/'> ($ Id.VSub_DollarName port)
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op: <Id.Redir_Great '2>'>
                                          loc: (redir_loc.Fd fd:2)
                                          arg: {<'/dev/null'>}
                                        )
                                      ]
                                      do_fork: T
                                    )
                                  ]
                                  ops: [<Id.Op_DAmp _>]
                                )
                              ]
                            )
                          then_kw: <Id.KW_Then then>
                          action: [
                            (command.AndOr
                              children: [
                                (command.Simple
                                  blame_tok: <test>
                                  more_env: []
                                  words: [
                                    {<test>}
                                    {<0>}
                                    {<Id.KW_Bang '!'> <Id.Lit_Equals '='>}
                                    {($ Id.VSub_DollarName verbose)}
                                  ]
                                  redirects: []
                                  do_fork: T
                                )
                                (command.Simple
                                  blame_tok: <echo>
                                  more_env: []
                                  words: [
                                    {<echo>}
                                    {
                                      (DQ ($ Id.VSub_DollarName command) <': using /dev/tcp/'> 
                                        ($ Id.VSub_DollarName host) <'/'> ($ Id.VSub_DollarName port)
                                      )
                                    }
                                  ]
                                  redirects: [
                                    (Redir
                                      op: <Id.Redir_GreatAnd '>&'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {<2>}
                                    )
                                  ]
                                  do_fork: T
                                )
                              ]
                              ops: [<Id.Op_DAmp _>]
                            )
                            (command.If
                              if_kw: <Id.KW_If if>
                              arms: [
                                (IfArm
                                  keyword: <Id.KW_If if>
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Pipeline
                                          negated: <Id.KW_Bang '!'>
                                          children: [
                                            (command.Simple
                                              blame_tok: <echo>
                                              more_env: []
                                              words: [
                                                {<echo>}
                                                {
                                                  (DQ <'GET '> ($ Id.VSub_DollarName path) 
                                                    <' HTTP/1.0\r\n'> <'Host: '> ($ Id.VSub_DollarName host) <'\r\n'> <'User-Agent: '> ($ Id.VSub_DollarName agent) <'\r'> 
                                                    (${ Id.VSub_Name AUTHORIZE) <'\n'> <'\r'>
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (Redir
                                                  op: <Id.Redir_GreatAnd '>&'>
                                                  loc: (redir_loc.Fd fd:1)
                                                  arg: {<8>}
                                                )
                                              ]
                                              do_fork: T
                                            )
                                          ]
                                          ops: []
                                        )
                                      ]
                                    )
                                  then_kw: <Id.KW_Then then>
                                  action: [
                                    (command.Simple
                                      blame_tok: <echo>
                                      more_env: []
                                      words: [
                                        {<echo>}
                                        {
                                          (DQ ($ Id.VSub_DollarName command) <': '> 
                                            ($ Id.VSub_DollarName host) <': write error'>
                                          )
                                        }
                                      ]
                                      redirects: []
                                      do_fork: T
                                    )
                                    (command.ControlFlow
                                      keyword: <Id.ControlFlow_Exit exit>
                                      arg_word: {<1>}
                                    )
                                  ]
                                  spids: [656 683]
                                )
                              ]
                              else_action: []
                              fi_kw: <Id.KW_Fi fi>
                              redirects: []
                            )
                            (BraceGroup
                              left: <Id.Lit_LBrace '{'>
                              children: [
                                (command.If
                                  if_kw: <Id.KW_If if>
                                  arms: [
                                    (IfArm
                                      keyword: <Id.KW_If if>
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (command.Pipeline
                                              negated: <Id.KW_Bang '!'>
                                              children: [
                                                (command.Simple
                                                  blame_tok: <read>
                                                  more_env: []
                                                  words: [{<read>} {<prot>} {<code>} {<text>}]
                                                  redirects: []
                                                  do_fork: T
                                                )
                                              ]
                                              ops: []
                                            )
                                          ]
                                        )
                                      then_kw: <Id.KW_Then then>
                                      action: [
                                        (command.Simple
                                          blame_tok: <echo>
                                          more_env: []
                                          words: [
                                            {<echo>}
                                            {
                                              (DQ ($ Id.VSub_DollarName command) <': '> 
                                                ($ Id.VSub_DollarName host) <': read error'>
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (Redir
                                              op: <Id.Redir_GreatAnd '>&'>
                                              loc: (redir_loc.Fd fd:1)
                                              arg: {<2>}
                                            )
                                          ]
                                          do_fork: T
                                        )
                                        (command.ControlFlow
                                          keyword: <Id.ControlFlow_Exit exit>
                                          arg_word: {<1>}
                                        )
                                      ]
                                      spids: [706 719]
                                    )
                                  ]
                                  else_action: []
                                  fi_kw: <Id.KW_Fi fi>
                                  redirects: []
                                )
                                (command.ShAssignment
                                  left: <Id.Lit_VarLike 'code='>
                                  pairs: [
                                    (AssignPair
                                      left: <Id.Lit_VarLike 'code='>
                                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'code='> name:code)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (BracedVarSub
                                            left: <Id.Left_DollarBrace '${'>
                                            token: <Id.VSub_Name code>
                                            var_name: code
                                            suffix_op: 
                                              (suffix_op.Unary
                                                op: <Id.VOp1_Percent '%'>
                                                arg_word: {<':'> <Id.Lit_Other '*'>}
                                              )
                                            right: <Id.Right_DollarBrace '}'>
                                          )
                                        }
                                    )
                                  ]
                                  redirects: []
                                )
                                (command.ShAssignment
                                  left: <Id.Lit_VarLike 'type='>
                                  pairs: [
                                    (AssignPair
                                      left: <Id.Lit_VarLike 'type='>
                                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'type='> name:type)
                                      op: assign_op.Equal
                                      rhs: {<Basic>}
                                    )
                                  ]
                                  redirects: []
                                )
                                (command.ShAssignment
                                  left: <Id.Lit_VarLike 'realm='>
                                  pairs: [
                                    (AssignPair
                                      left: <Id.Lit_VarLike 'realm='>
                                      lhs: 
                                        (sh_lhs_expr.Name
                                          left: <Id.Lit_VarLike 'realm='>
                                          name: realm
                                        )
                                      op: assign_op.Equal
                                      rhs: {<access>}
                                    )
                                  ]
                                  redirects: []
                                )
                                (command.AndOr
                                  children: [
                                    (command.Simple
                                      blame_tok: <test>
                                      more_env: []
                                      words: [
                                        {<test>}
                                        {<0>}
                                        {<Id.KW_Bang '!'> <Id.Lit_Equals '='>}
                                        {($ Id.VSub_DollarName verbose)}
                                      ]
                                      redirects: []
                                      do_fork: T
                                    )
                                    (command.Simple
                                      blame_tok: <echo>
                                      more_env: []
                                      words: [
                                        {<echo>}
                                        {
                                          (DQ ($ Id.VSub_DollarName command) <': prot='> 
                                            ($ Id.VSub_DollarName prot) <' code='> ($ Id.VSub_DollarName code) <' '> ($ Id.VSub_DollarName text)
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op: <Id.Redir_GreatAnd '>&'>
                                          loc: (redir_loc.Fd fd:1)
                                          arg: {<2>}
                                        )
                                      ]
                                      do_fork: T
                                    )
                                  ]
                                  ops: [<Id.Op_DAmp _>]
                                )
                                (command.WhileUntil
                                  keyword: <Id.KW_While while>
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Simple
                                          blame_tok: <Id.Lit_Colon ':'>
                                          more_env: []
                                          words: [{<Id.Lit_Colon ':'>}]
                                          redirects: []
                                          do_fork: T
                                        )
                                      ]
                                    )
                                  body: 
                                    (command.DoGroup
                                      left: <Id.KW_Do do>
                                      children: [
                                        (command.If
                                          if_kw: <Id.KW_If if>
                                          arms: [
                                            (IfArm
                                              keyword: <Id.KW_If if>
                                              cond: 
                                                (condition.Shell
                                                  commands: [
                                                    (command.Pipeline
                                                      negated: <Id.KW_Bang '!'>
                                                      children: [
                                                        (command.Simple
                                                          blame_tok: <read>
                                                          more_env: []
                                                          words: [{<read>} {<head>} {<Id.KW_Data data>}]
                                                          redirects: []
                                                          do_fork: T
                                                        )
                                                      ]
                                                      ops: []
                                                    )
                                                  ]
                                                )
                                              then_kw: <Id.KW_Then then>
                                              action: [
                                                (command.Simple
                                                  blame_tok: <echo>
                                                  more_env: []
                                                  words: [
                                                    {<echo>}
                                                    {
                                                      (DQ ($ Id.VSub_DollarName command) <': '> 
                                                        ($ Id.VSub_DollarName host) <': read error'>
                                                      )
                                                    }
                                                  ]
                                                  redirects: [
                                                    (Redir
                                                      op: <Id.Redir_GreatAnd '>&'>
                                                      loc: (redir_loc.Fd fd:1)
                                                      arg: {<2>}
                                                    )
                                                  ]
                                                  do_fork: T
                                                )
                                                (command.ControlFlow
                                                  keyword: <Id.ControlFlow_Exit exit>
                                                  arg_word: {<1>}
                                                )
                                              ]
                                              spids: [793 804]
                                            )
                                          ]
                                          else_action: []
                                          fi_kw: <Id.KW_Fi fi>
                                          redirects: []
                                        )
                                        (command.AndOr
                                          children: [
                                            (command.Simple
                                              blame_tok: <test>
                                              more_env: []
                                              words: [
                                                {<test>}
                                                {<0>}
                                                {<Id.KW_Bang '!'> <Id.Lit_Equals '='>}
                                                {($ Id.VSub_DollarName verbose)}
                                              ]
                                              redirects: []
                                              do_fork: T
                                            )
                                            (command.Simple
                                              blame_tok: <echo>
                                              more_env: []
                                              words: [
                                                {<echo>}
                                                {
                                                  (DQ ($ Id.VSub_DollarName command) <': head='> 
                                                    ($ Id.VSub_DollarName head) <' '> ($ Id.VSub_DollarName data)
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (Redir
                                                  op: <Id.Redir_GreatAnd '>&'>
                                                  loc: (redir_loc.Fd fd:1)
                                                  arg: {<2>}
                                                )
                                              ]
                                              do_fork: T
                                            )
                                          ]
                                          ops: [<Id.Op_DAmp _>]
                                        )
                                        (command.Case
                                          case_kw: <Id.KW_Case case>
                                          to_match: (case_arg.Word w:{($ Id.VSub_DollarName head)})
                                          arms_start: <Id.KW_In in>
                                          arms: [
                                            (CaseArm
                                              left: <Location>
                                              pattern: 
                                                (pat.Words
                                                  words: [{<Location> <Id.Lit_Colon ':'>}]
                                                )
                                              middle: <Id.Right_CasePat _>
                                              action: [
                                                (command.Case
                                                  case_kw: <Id.KW_Case case>
                                                  to_match: 
                                                    (case_arg.Word
                                                      w: {($ Id.VSub_DollarName code)}
                                                    )
                                                  arms_start: <Id.KW_In in>
                                                  arms: [
                                                    (CaseArm
                                                      left: <30>
                                                      pattern: 
                                                        (pat.Words
                                                          words: [
                                                            {<30> <Id.Lit_LBracket '['> <123> 
                                                              <Id.Lit_RBracket ']'>
                                                            }
                                                          ]
                                                        )
                                                      middle: <Id.Right_CasePat _>
                                                      action: [
                                                        (command.ShAssignment
                                                          left: <Id.Lit_VarLike 'url='>
                                                          pairs: [
                                                            (AssignPair
                                                              left: <Id.Lit_VarLike 'url='>
                                                              lhs: 
                                                                (sh_lhs_expr.Name
                                                                  left: <Id.Lit_VarLike 'url='>
                                                                  name: url
                                                                )
                                                              op: assign_op.Equal
                                                              rhs: {($ Id.VSub_DollarName data)}
                                                            )
                                                          ]
                                                          redirects: []
                                                        )
                                                        (command.ControlFlow
                                                          keyword: <Id.ControlFlow_Continue continue>
                                                          arg_word: {<2>}
                                                        )
                                                      ]
                                                      right: <Id.Op_DSemi _>
                                                    )
                                                  ]
                                                  arms_end: <Id.KW_Esac esac>
                                                  redirects: []
                                                )
                                              ]
                                              right: <Id.Op_DSemi _>
                                            )
                                            (CaseArm
                                              left: <WWW-Authenticate>
                                              pattern: 
                                                (pat.Words
                                                  words: [{<WWW-Authenticate> <Id.Lit_Colon ':'>}]
                                                )
                                              middle: <Id.Right_CasePat _>
                                              action: [
                                                (command.Simple
                                                  blame_tok: <set>
                                                  more_env: []
                                                  words: [{<set>} {<-->} {($ Id.VSub_DollarName data)}]
                                                  redirects: []
                                                  do_fork: T
                                                )
                                                (command.ShAssignment
                                                  left: <Id.Lit_VarLike 'type='>
                                                  pairs: [
                                                    (AssignPair
                                                      left: <Id.Lit_VarLike 'type='>
                                                      lhs: 
                                                        (sh_lhs_expr.Name
                                                          left: <Id.Lit_VarLike 'type='>
                                                          name: type
                                                        )
                                                      op: assign_op.Equal
                                                      rhs: {($ Id.VSub_Number 1)}
                                                    )
                                                  ]
                                                  redirects: []
                                                )
                                                (command.Simple
                                                  blame_tok: <shift>
                                                  more_env: []
                                                  words: [{<shift>}]
                                                  redirects: []
                                                  do_fork: T
                                                )
                                                (command.Simple
                                                  blame_tok: <eval>
                                                  more_env: []
                                                  words: [{<eval>} {(DQ ($ Id.VSub_At '@'))}]
                                                  redirects: []
                                                  do_fork: T
                                                )
                                                (command.ShAssignment
                                                  left: <Id.Lit_VarLike 'realm='>
                                                  pairs: [
                                                    (AssignPair
                                                      left: <Id.Lit_VarLike 'realm='>
                                                      lhs: 
                                                        (sh_lhs_expr.Name
                                                          left: <Id.Lit_VarLike 'realm='>
                                                          name: realm
                                                        )
                                                      op: assign_op.Equal
                                                      rhs: 
                                                        {
                                                          (BracedVarSub
                                                            left: <Id.Left_DollarBrace '${'>
                                                            token: <Id.VSub_Name realm>
                                                            var_name: realm
                                                            suffix_op: 
                                                              (suffix_op.Unary
                                                                op: <Id.VOp1_Percent '%'>
                                                                arg_word: 
                                                                  {
                                                                    (SingleQuoted
                                                                      left: 
                                                                        <Id.Left_DollarSingleQuote 
'$\''
                                                                        >
                                                                      tokens: [
                                                                        <Id.Char_OneChar '\\r'>
                                                                      ]
                                                                      right: 
                                                                        <Id.Right_SingleQuote '\''>
                                                                    )
                                                                  }
                                                              )
                                                            right: <Id.Right_DollarBrace '}'>
                                                          )
                                                        }
                                                    )
                                                  ]
                                                  redirects: []
                                                )
                                              ]
                                              right: <Id.Op_DSemi _>
                                            )
                                            (CaseArm
                                              left: <Id.Left_SingleQuote '\''>
                                              pattern: 
                                                (pat.Words
                                                  words: [{(SQ )} {<Id.Lit_QMark '?'>}]
                                                )
                                              middle: <Id.Right_CasePat _>
                                              action: [
                                                (command.ControlFlow
                                                  keyword: <Id.ControlFlow_Break break>
                                                )
                                              ]
                                              right: <Id.Op_DSemi _>
                                            )
                                          ]
                                          arms_end: <Id.KW_Esac esac>
                                          redirects: []
                                        )
                                      ]
                                      right: <Id.KW_Done done>
                                    )
                                  redirects: []
                                )
                                (command.Case
                                  case_kw: <Id.KW_Case case>
                                  to_match: (case_arg.Word w:{($ Id.VSub_DollarName code)})
                                  arms_start: <Id.KW_In in>
                                  arms: [
                                    (CaseArm
                                      left: <200>
                                      pattern: (pat.Words words:[{<200>}])
                                      middle: <Id.Right_CasePat _>
                                      action: [
                                        (command.If
                                          if_kw: <Id.KW_If if>
                                          arms: [
                                            (IfArm
                                              keyword: <Id.KW_If if>
                                              cond: 
                                                (condition.Shell
                                                  commands: [
                                                    (command.DParen
                                                      left: <Id.Op_DLeftParen _>
                                                      child: ($ Id.Lit_ArithVarLike limit)
                                                      right: <Id.Op_DRightParen _>
                                                      redirects: []
                                                    )
                                                  ]
                                                )
                                              then_kw: <Id.KW_Then then>
                                              action: [
                                                (command.DParen
                                                  left: <Id.Op_DLeftParen _>
                                                  child: 
                                                    (arith_expr.BinaryAssign
                                                      op_id: Id.Arith_Equal
                                                      left: ($ Id.Lit_ArithVarLike limit)
                                                      right: 
                                                        (arith_expr.Binary
                                                          op_id: Id.Arith_Slash
                                                          left: 
                                                            (arith_expr.Binary
                                                              op_id: Id.Arith_Minus
                                                              left: 
                                                                (arith_expr.Binary
                                                                  op_id: Id.Arith_Plus
                                                                  left: ($ Id.Lit_ArithVarLike limit)
                                                                  right: 
                                                                    ($ Id.Lit_ArithVarLike block)
                                                                )
                                                              right: {<Id.Lit_Digits 1>}
                                                            )
                                                          right: ($ Id.Lit_ArithVarLike block)
                                                        )
                                                    )
                                                  right: <Id.Op_DRightParen _>
                                                  redirects: []
                                                )
                                                (command.Simple
                                                  blame_tok: <dd>
                                                  more_env: []
                                                  words: [
                                                    {<dd>}
                                                    {<Id.Lit_VarLike 'bs='> 
                                                      ($ Id.VSub_DollarName block)
                                                    }
                                                    {<Id.Lit_VarLike 'count='> 
                                                      ($ Id.VSub_DollarName limit)
                                                    }
                                                    {<Id.Lit_VarLike 'silent='> <1>}
                                                  ]
                                                  redirects: []
                                                  do_fork: T
                                                )
                                              ]
                                              spids: [961 971]
                                            )
                                          ]
                                          else_kw: <Id.KW_Else else>
                                          else_action: [
                                            (command.Simple
                                              blame_tok: <cat>
                                              more_env: []
                                              words: [{<cat>}]
                                              redirects: []
                                              do_fork: T
                                            )
                                          ]
                                          fi_kw: <Id.KW_Fi fi>
                                          redirects: []
                                        )
                                        (command.ControlFlow
                                          keyword: <Id.ControlFlow_Exit exit>
                                        )
                                      ]
                                      right: <Id.Op_DSemi _>
                                    )
                                    (CaseArm
                                      left: <401>
                                      pattern: (pat.Words words:[{<401>}])
                                      middle: <Id.Right_CasePat _>
                                      action: [
                                        (BraceGroup
                                          left: <Id.Lit_LBrace '{'>
                                          children: [
                                            (command.If
                                              if_kw: <Id.KW_If if>
                                              arms: [
                                                (IfArm
                                                  keyword: <Id.KW_If if>
                                                  cond: 
                                                    (condition.Shell
                                                      commands: [
                                                        (command.DBracket
                                                          left: <Id.KW_DLeftBracket '[['>
                                                          expr: 
                                                            (bool_expr.LogicalOr
                                                              left: 
                                                                (bool_expr.WordTest
                                                                  w: 
                                                                    {
                                                                      ($ Id.VSub_DollarName AUTHORIZE)
                                                                    }
                                                                )
                                                              right: 
                                                                (bool_expr.Binary
                                                                  op_id: Id.BoolBinary_GlobNEqual
                                                                  left: {($ Id.VSub_DollarName type)}
                                                                  right: {<Basic>}
                                                                )
                                                            )
                                                          right: <Id.Lit_DRightBracket ']]'>
                                                          redirects: []
                                                        )
                                                      ]
                                                    )
                                                  then_kw: <Id.KW_Then then>
                                                  action: [
                                                    (command.Simple
                                                      blame_tok: <print>
                                                      more_env: []
                                                      words: [{<print>} {<authorization>} {<failed>}]
                                                      redirects: []
                                                      do_fork: T
                                                    )
                                                    (command.ControlFlow
                                                      keyword: <Id.ControlFlow_Exit exit>
                                                      arg_word: {<1>}
                                                    )
                                                  ]
                                                  spids: [1030 1047]
                                                )
                                              ]
                                              else_action: []
                                              fi_kw: <Id.KW_Fi fi>
                                              redirects: []
                                            )
                                            (command.If
                                              if_kw: <Id.KW_If if>
                                              arms: [
                                                (IfArm
                                                  keyword: <Id.KW_If if>
                                                  cond: 
                                                    (condition.Shell
                                                      commands: [
                                                        (command.DBracket
                                                          left: <Id.KW_DLeftBracket '[['>
                                                          expr: 
                                                            (bool_expr.LogicalNot
                                                              child: 
                                                                (bool_expr.WordTest
                                                                  w: 
                                                                    {
                                                                      ($ Id.VSub_DollarName authorize)
                                                                    }
                                                                )
                                                            )
                                                          right: <Id.Lit_DRightBracket ']]'>
                                                          redirects: []
                                                        )
                                                      ]
                                                    )
                                                  then_kw: <Id.KW_Then then>
                                                  action: [
                                                    (command.If
                                                      if_kw: <Id.KW_If if>
                                                      arms: [
                                                        (IfArm
                                                          keyword: <Id.KW_If if>
                                                          cond: 
                                                            (condition.Shell
                                                              commands: [
                                                                (command.DBracket
                                                                  left: <Id.KW_DLeftBracket '[['>
                                                                  expr: 
                                                                    (bool_expr.LogicalNot
                                                                      child: 
                                                                        (bool_expr.Unary
                                                                          op_id: Id.BoolUnary_t
                                                                          child: {<0>}
                                                                        )
                                                                    )
                                                                  right: <Id.Lit_DRightBracket ']]'>
                                                                  redirects: []
                                                                )
                                                              ]
                                                            )
                                                          then_kw: <Id.KW_Then then>
                                                          action: [
                                                            (command.Simple
                                                              blame_tok: <print>
                                                              more_env: []
                                                              words: [
                                                                {<print>}
                                                                {<authorization>}
                                                                {<failed>}
                                                              ]
                                                              redirects: []
                                                              do_fork: T
                                                            )
                                                            (command.ControlFlow
                                                              keyword: <Id.ControlFlow_Exit exit>
                                                              arg_word: {<1>}
                                                            )
                                                          ]
                                                          spids: [1077 1090]
                                                        )
                                                      ]
                                                      else_action: []
                                                      fi_kw: <Id.KW_Fi fi>
                                                      redirects: []
                                                    )
                                                    (command.Simple
                                                      blame_tok: <print>
                                                      more_env: []
                                                      words: [
                                                        {<print>}
                                                        {<-n>}
                                                        {
                                                          (DQ <'Enter user name for '> 
                                                            ($ Id.VSub_DollarName realm) <': '>
                                                          )
                                                        }
                                                      ]
                                                      redirects: []
                                                      do_fork: T
                                                    )
                                                    (command.Simple
                                                      blame_tok: <read>
                                                      more_env: []
                                                      words: [{<read>} {<-u9>} {<user>}]
                                                      redirects: []
                                                      do_fork: T
                                                    )
                                                    (command.Simple
                                                      blame_tok: <print>
                                                      more_env: []
                                                      words: [{<print>} {<-n>} {(DQ <'Password: '>)}]
                                                      redirects: []
                                                      do_fork: T
                                                    )
                                                    (command.Simple
                                                      blame_tok: <trap>
                                                      more_env: []
                                                      words: [
                                                        {<trap>}
                                                        {(SQ <'stty echo <&9'>)}
                                                        {<0>}
                                                        {<1>}
                                                        {<2>}
                                                        {<3>}
                                                        {<15>}
                                                      ]
                                                      redirects: []
                                                      do_fork: T
                                                    )
                                                    (command.Simple
                                                      blame_tok: <stty>
                                                      more_env: []
                                                      words: [{<stty>} {<-echo>}]
                                                      redirects: []
                                                      do_fork: T
                                                    )
                                                    (command.Simple
                                                      blame_tok: <read>
                                                      more_env: []
                                                      words: [{<read>} {<password>}]
                                                      redirects: []
                                                      do_fork: T
                                                    )
                                                    (command.Simple
                                                      blame_tok: <stty>
                                                      more_env: []
                                                      words: [{<stty>} {<echo>}]
                                                      redirects: []
                                                      do_fork: T
                                                    )
                                                    (command.Simple
                                                      blame_tok: <print>
                                                      more_env: []
                                                      words: [{<print>}]
                                                      redirects: []
                                                      do_fork: T
                                                    )
                                                    (command.Simple
                                                      blame_tok: <trap>
                                                      more_env: []
                                                      words: [{<trap>} {<->} {<0>} {<1>} {<2>} {<3>} {<15>}]
                                                      redirects: []
                                                      do_fork: T
                                                    )
                                                    (command.ShAssignment
                                                      left: <Id.Lit_VarLike 'authorize='>
                                                      pairs: [
                                                        (AssignPair
                                                          left: <Id.Lit_VarLike 'authorize='>
                                                          lhs: 
                                                            (sh_lhs_expr.Name
                                                              left: <Id.Lit_VarLike 'authorize='>
                                                              name: authorize
                                                            )
                                                          op: assign_op.Equal
                                                          rhs: 
                                                            {($ Id.VSub_DollarName user) 
                                                              <Id.Lit_Colon ':'> ($ Id.VSub_DollarName password)
                                                            }
                                                        )
                                                      ]
                                                      redirects: []
                                                    )
                                                  ]
                                                  spids: [1064 1075]
                                                )
                                              ]
                                              else_action: []
                                              fi_kw: <Id.KW_Fi fi>
                                              redirects: []
                                            )
                                            (command.ShAssignment
                                              left: <Id.Lit_VarLike 'AUTHORIZE='>
                                              pairs: [
                                                (AssignPair
                                                  left: <Id.Lit_VarLike 'AUTHORIZE='>
                                                  lhs: 
                                                    (sh_lhs_expr.Name
                                                      left: <Id.Lit_VarLike 'AUTHORIZE='>
                                                      name: AUTHORIZE
                                                    )
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (SingleQuoted
                                                        left: <Id.Left_DollarSingleQuote '$\''>
                                                        tokens: [
                                                          <Id.Char_OneChar '\\n'>
                                                          <Id.Char_Literals 'Authorization: '>
                                                        ]
                                                        right: <Id.Right_SingleQuote '\''>
                                                      ) ($ Id.VSub_DollarName type) (SQ <' '>) 
                                                      (CommandSub
                                                        left_token: <Id.Left_DollarParen '$('>
                                                        child: 
                                                          (command.Pipeline
                                                            children: [
                                                              (command.Simple
                                                                blame_tok: <print>
                                                                more_env: []
                                                                words: [
                                                                  {<print>}
                                                                  {<-n>}
                                                                  {<-r>}
                                                                  {<-->}
                                                                  {
                                                                    (DQ 
                                                                      ($ Id.VSub_DollarName authorize)
                                                                    )
                                                                  }
                                                                ]
                                                                redirects: []
                                                                do_fork: T
                                                              )
                                                              (command.Simple
                                                                blame_tok: <uuencode>
                                                                more_env: []
                                                                words: [
                                                                  {<uuencode>}
                                                                  {<-h>}
                                                                  {<-x>}
                                                                  {<base64>}
                                                                ]
                                                                redirects: []
                                                                do_fork: T
                                                              )
                                                            ]
                                                            ops: [<Id.Op_Pipe _>]
                                                          )
                                                        right: <Id.Eof_RParen _>
                                                      ) 
                                                      (SingleQuoted
                                                        left: <Id.Left_DollarSingleQuote '$\''>
                                                        tokens: [<Id.Char_OneChar '\\r'>]
                                                        right: <Id.Right_SingleQuote '\''>
                                                      )
                                                    }
                                                )
                                              ]
                                              redirects: []
                                            )
                                          ]
                                          redirects: [
                                            (Redir
                                              op: <Id.Redir_LessAnd '<&'>
                                              loc: (redir_loc.Fd fd:0)
                                              arg: {<9>}
                                            )
                                            (Redir
                                              op: <Id.Redir_GreatAnd '>&'>
                                              loc: (redir_loc.Fd fd:1)
                                              arg: {<2>}
                                            )
                                          ]
                                          right: <Id.Lit_RBrace '}'>
                                        )
                                        (command.ControlFlow
                                          keyword: <Id.ControlFlow_Continue continue>
                                          arg_word: {<2>}
                                        )
                                      ]
                                      right: <Id.Op_DSemi _>
                                    )
                                    (CaseArm
                                      left: <Id.Lit_Star '*'>
                                      pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
                                      middle: <Id.Right_CasePat _>
                                      action: [
                                        (command.Simple
                                          blame_tok: <echo>
                                          more_env: []
                                          words: [
                                            {<echo>}
                                            {
                                              (DQ ($ Id.VSub_Number 0) <': '> 
                                                ($ Id.VSub_DollarName url) <': '> ($ Id.VSub_DollarName code) <': '> ($ Id.VSub_DollarName text)
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (Redir
                                              op: <Id.Redir_GreatAnd '>&'>
                                              loc: (redir_loc.Fd fd:1)
                                              arg: {<2>}
                                            )
                                          ]
                                          do_fork: T
                                        )
                                        (command.ControlFlow
                                          keyword: <Id.ControlFlow_Exit exit>
                                          arg_word: {<1>}
                                        )
                                      ]
                                      right: <Id.Op_DSemi _>
                                    )
                                  ]
                                  arms_end: <Id.KW_Esac esac>
                                  redirects: []
                                )
                              ]
                              redirects: [
                                (Redir
                                  op: <Id.Redir_LessAnd '<&'>
                                  loc: (redir_loc.Fd fd:0)
                                  arg: {<8>}
                                )
                              ]
                              right: <Id.Lit_RBrace '}'>
                            )
                          ]
                          spids: [594 629]
                        )
                        (IfArm
                          keyword: <Id.KW_Elif elif>
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Simple
                                  blame_tok: <wget>
                                  more_env: []
                                  words: [
                                    {<wget>}
                                    {
                                      (BracedVarSub
                                        left: <Id.Left_DollarBrace '${'>
                                        token: <Id.VSub_Name authorize>
                                        var_name: authorize
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op: <Id.VTest_ColonPlus _>
                                            arg_word: 
                                              {<'--http-user='> 
                                                (DQ 
                                                  (BracedVarSub
                                                    left: <Id.Left_DollarBrace '${'>
                                                    token: <Id.VSub_Name authorize>
                                                    var_name: authorize
                                                    suffix_op: 
                                                      (suffix_op.Unary
                                                        op: <Id.VOp1_Percent '%'>
                                                        arg_word: {<':'> <Id.Lit_Other '*'>}
                                                      )
                                                    right: <Id.Right_DollarBrace '}'>
                                                  )
                                                )
                                              }
                                          )
                                        right: <Id.Right_DollarBrace '}'>
                                      )
                                    }
                                    {
                                      (BracedVarSub
                                        left: <Id.Left_DollarBrace '${'>
                                        token: <Id.VSub_Name password>
                                        var_name: password
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op: <Id.VTest_ColonPlus _>
                                            arg_word: 
                                              {<'--http-passwd='> 
                                                (DQ 
                                                  (BracedVarSub
                                                    left: <Id.Left_DollarBrace '${'>
                                                    token: <Id.VSub_Name password>
                                                    var_name: password
                                                    suffix_op: 
                                                      (suffix_op.Unary
                                                        op: <Id.VOp1_DPound '##'>
                                                        arg_word: {<Id.Lit_Other '*'> <':'>}
                                                      )
                                                    right: <Id.Right_DollarBrace '}'>
                                                  )
                                                )
                                              }
                                          )
                                        right: <Id.Right_DollarBrace '}'>
                                      )
                                    }
                                    {<-nv>}
                                    {<-O>}
                                    {<->}
                                    {($ Id.VSub_DollarName url)}
                                  ]
                                  redirects: [
                                    (Redir
                                      op: <Id.Redir_Great '2>'>
                                      loc: (redir_loc.Fd fd:2)
                                      arg: {<'/dev/null'>}
                                    )
                                  ]
                                  do_fork: T
                                )
                              ]
                            )
                          then_kw: <Id.KW_Then then>
                          action: [
                            (command.AndOr
                              children: [
                                (command.Simple
                                  blame_tok: <test>
                                  more_env: []
                                  words: [
                                    {<test>}
                                    {<0>}
                                    {<Id.KW_Bang '!'> <Id.Lit_Equals '='>}
                                    {($ Id.VSub_DollarName verbose)}
                                  ]
                                  redirects: []
                                  do_fork: T
                                )
                                (command.Simple
                                  blame_tok: <echo>
                                  more_env: []
                                  words: [
                                    {<echo>}
                                    {(DQ ($ Id.VSub_DollarName command) <': using wget'>)}
                                  ]
                                  redirects: [
                                    (Redir
                                      op: <Id.Redir_GreatAnd '>&'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {<2>}
                                    )
                                  ]
                                  do_fork: T
                                )
                              ]
                              ops: [<Id.Op_DAmp _>]
                            )
                            (command.ControlFlow
                              keyword: <Id.ControlFlow_Exit exit>
                            )
                          ]
                          spids: [1284 1328]
                        )
                        (IfArm
                          keyword: <Id.KW_Elif elif>
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Simple
                                  blame_tok: <lynx>
                                  more_env: []
                                  words: [
                                    {<lynx>}
                                    {
                                      (BracedVarSub
                                        left: <Id.Left_DollarBrace '${'>
                                        token: <Id.VSub_Name authorize>
                                        var_name: authorize
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op: <Id.VTest_ColonPlus _>
                                            arg_word: 
                                              {<'-auth '> (DQ ($ Id.VSub_DollarName authorize))}
                                          )
                                        right: <Id.Right_DollarBrace '}'>
                                      )
                                    }
                                    {<-source>}
                                    {($ Id.VSub_DollarName url)}
                                  ]
                                  redirects: [
                                    (Redir
                                      op: <Id.Redir_Great '2>'>
                                      loc: (redir_loc.Fd fd:2)
                                      arg: {<'/dev/null'>}
                                    )
                                  ]
                                  do_fork: T
                                )
                              ]
                            )
                          then_kw: <Id.KW_Then then>
                          action: [
                            (command.AndOr
                              children: [
                                (command.Simple
                                  blame_tok: <test>
                                  more_env: []
                                  words: [
                                    {<test>}
                                    {<0>}
                                    {<Id.KW_Bang '!'> <Id.Lit_Equals '='>}
                                    {($ Id.VSub_DollarName verbose)}
                                  ]
                                  redirects: []
                                  do_fork: T
                                )
                                (command.Simple
                                  blame_tok: <echo>
                                  more_env: []
                                  words: [
                                    {<echo>}
                                    {(DQ ($ Id.VSub_DollarName command) <': using wget'>)}
                                  ]
                                  redirects: [
                                    (Redir
                                      op: <Id.Redir_GreatAnd '>&'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {<2>}
                                    )
                                  ]
                                  do_fork: T
                                )
                              ]
                              ops: [<Id.Op_DAmp _>]
                            )
                            (command.ControlFlow
                              keyword: <Id.ControlFlow_Exit exit>
                            )
                          ]
                          spids: [1355 1376]
                        )
                        (IfArm
                          keyword: <Id.KW_Elif elif>
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Simple
                                  blame_tok: <curl>
                                  more_env: []
                                  words: [
                                    {<curl>}
                                    {
                                      (BracedVarSub
                                        left: <Id.Left_DollarBrace '${'>
                                        token: <Id.VSub_Name authorize>
                                        var_name: authorize
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op: <Id.VTest_ColonPlus _>
                                            arg_word: {<'-u '> (DQ ($ Id.VSub_DollarName authorize))}
                                          )
                                        right: <Id.Right_DollarBrace '}'>
                                      )
                                    }
                                    {<-s>}
                                    {<-L>}
                                    {<-o>}
                                    {<->}
                                    {($ Id.VSub_DollarName url)}
                                  ]
                                  redirects: [
                                    (Redir
                                      op: <Id.Redir_Great '2>'>
                                      loc: (redir_loc.Fd fd:2)
                                      arg: {<'/dev/null'>}
                                    )
                                  ]
                                  do_fork: T
                                )
                              ]
                            )
                          then_kw: <Id.KW_Then then>
                          action: [
                            (command.AndOr
                              children: [
                                (command.Simple
                                  blame_tok: <test>
                                  more_env: []
                                  words: [
                                    {<test>}
                                    {<0>}
                                    {<Id.KW_Bang '!'> <Id.Lit_Equals '='>}
                                    {($ Id.VSub_DollarName verbose)}
                                  ]
                                  redirects: []
                                  do_fork: T
                                )
                                (command.Simple
                                  blame_tok: <echo>
                                  more_env: []
                                  words: [
                                    {<echo>}
                                    {(DQ ($ Id.VSub_DollarName command) <': using curl'>)}
                                  ]
                                  redirects: [
                                    (Redir
                                      op: <Id.Redir_GreatAnd '>&'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {<2>}
                                    )
                                  ]
                                  do_fork: T
                                )
                              ]
                              ops: [<Id.Op_DAmp _>]
                            )
                            (command.ControlFlow
                              keyword: <Id.ControlFlow_Exit exit>
                            )
                          ]
                          spids: [1403 1430]
                        )
                      ]
                      else_kw: <Id.KW_Else else>
                      else_action: [
                        (command.Simple
                          blame_tok: <echo>
                          more_env: []
                          words: [
                            {<echo>}
                            {
                              (DQ ($ Id.VSub_DollarName command) <': '> ($ Id.VSub_DollarName url) 
                                <': { /dev/tcp/'> ($ Id.VSub_DollarName host) <'/'> ($ Id.VSub_DollarName port) <' wget curl } failed'>
                              )
                            }
                          ]
                          redirects: [
                            (Redir
                              op: <Id.Redir_GreatAnd '>&'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<2>}
                            )
                          ]
                          do_fork: T
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Exit exit>
                          arg_word: {<1>}
                        )
                      ]
                      fi_kw: <Id.KW_Fi fi>
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <Id.Lit_Star '*'>
                  pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.Simple
                      blame_tok: <echo>
                      more_env: []
                      words: [
                        {<echo>}
                        {
                          (DQ ($ Id.VSub_DollarName command) <': '> ($ Id.VSub_DollarName prot) 
                            <': protocol not supported'>
                          )
                        }
                      ]
                      redirects: [(Redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
                      do_fork: T
                    )
                    (command.ControlFlow
                      keyword: <Id.ControlFlow_Exit exit>
                      arg_word: {<1>}
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
          ]
          right: <Id.KW_Done done>
        )
      redirects: []
    )
  ]
)