(command.CommandList
  children: [
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:ARGV0)
          op: assign_op.Equal
          rhs: 
            {
              (command_sub
                left_token: <Id.Left_Backtick '`'>
                command_list: 
                  (command.CommandList
                    children: [(C {<basename>} {(DQ ($ Id.VSub_Number '$0'))})]
                  )
              )
            }
          spids: [52]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:LSB_RELEASE)
          op: assign_op.Equal
          rhs: {(SQ </etc/lsb-release>)}
          spids: [63]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:VERSIONS_SHELLS)
          op: assign_op.Equal
          rhs: {(DQ <'ash /bin/bash /bin/dash /bin/ksh /bin/pdksh /bin/sh /bin/zsh'>)}
          spids: [68]
        )
      ]
    )
    (command.CommandList
      children: [
        (command.Sentence child:(C {<true>}) terminator:<Id.Op_Semi _>)
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:TRUE)
              op: assign_op.Equal
              rhs: {($ Id.VSub_QMark '$?')}
              spids: [77]
            )
          ]
        )
      ]
    )
    (command.CommandList
      children: [
        (command.Sentence child:(C {<false>}) terminator:<Id.Op_Semi _>)
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:FALSE)
              op: assign_op.Equal
              rhs: {($ Id.VSub_QMark '$?')}
              spids: [83]
            )
          ]
        )
      ]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:ERROR) op:assign_op.Equal rhs:{<2>} spids:[86])]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:UNAME_R)
          op: assign_op.Equal
          rhs: 
            {
              (command_sub
                left_token: <Id.Left_Backtick '`'>
                command_list: (command.CommandList children:[(C {<uname>} {<-r>})])
              )
            }
          spids: [90]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:UNAME_S)
          op: assign_op.Equal
          rhs: 
            {
              (command_sub
                left_token: <Id.Left_Backtick '`'>
                command_list: (command.CommandList children:[(C {<uname>} {<-s>})])
              )
            }
          spids: [99]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__versions_haveStrings)
          op: assign_op.Equal
          rhs: {(${ Id.VSub_Name ERROR)}
          spids: [109]
        )
      ]
    )
    (command.ShFunction
      name: versions_osName
      body: 
        (command.BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:os_name_)
                  op: assign_op.Equal
                  rhs: {(SQ <unrecognized>)}
                  spids: [122]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:os_system_)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name UNAME_S)}
                  spids: [128]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:os_release_)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name UNAME_R)}
                  spids: [134]
                )
              ]
            )
            (command.Case
              to_match: {(${ Id.VSub_Name os_system_)}
              arms: [
                (case_arm
                  pat_list: [{<CYGWIN_NT-> <Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:os_name_)
                          op: assign_op.Equal
                          rhs: {(SQ <Cygwin>)}
                          spids: [153]
                        )
                      ]
                    )
                  ]
                  spids: [149 151 158 -1]
                )
                (case_arm
                  pat_list: [{<Darwin>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:os_name_)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [(C {</usr/bin/sw_vers>} {<-productName>})]
                                  )
                              )
                            }
                          spids: [165]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:os_version_)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [(C {<versions_osVersion>})]
                                  )
                              )
                            }
                          spids: [175]
                        )
                      ]
                    )
                    (command.Case
                      to_match: {(${ Id.VSub_Name os_version_)}
                      arms: [
                        (case_arm
                          pat_list: [
                            {<10.4>}
                            {<10.4.> <Id.Lit_LBracket '['> <0-9> <Id.Lit_RBracket ']'> <Id.Lit_Star '*'>}
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:os_name_)
                                  op: assign_op.Equal
                                  rhs: {(SQ <'Mac OS X Tiger'>)}
                                  spids: [201]
                                )
                              ]
                            )
                          ]
                          spids: [192 199 206 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<10.5>}
                            {<10.5.> <Id.Lit_LBracket '['> <0-9> <Id.Lit_RBracket ']'> <Id.Lit_Star '*'>}
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:os_name_)
                                  op: assign_op.Equal
                                  rhs: {(SQ <'Mac OS X Leopard'>)}
                                  spids: [218]
                                )
                              ]
                            )
                          ]
                          spids: [209 216 223 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<10.6>}
                            {<10.6.> <Id.Lit_LBracket '['> <0-9> <Id.Lit_RBracket ']'> <Id.Lit_Star '*'>}
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:os_name_)
                                  op: assign_op.Equal
                                  rhs: {(SQ <'Mac OS X Snow Leopard'>)}
                                  spids: [235]
                                )
                              ]
                            )
                          ]
                          spids: [226 233 240 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<10.7>}
                            {<10.7.> <Id.Lit_LBracket '['> <0-9> <Id.Lit_RBracket ']'> <Id.Lit_Star '*'>}
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:os_name_)
                                  op: assign_op.Equal
                                  rhs: {(SQ <'Mac OS X Lion'>)}
                                  spids: [252]
                                )
                              ]
                            )
                          ]
                          spids: [243 250 257 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<10.8>}
                            {<10.8.> <Id.Lit_LBracket '['> <0-9> <Id.Lit_RBracket ']'> <Id.Lit_Star '*'>}
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:os_name_)
                                  op: assign_op.Equal
                                  rhs: {(SQ <'Mac OS X Mountain Lion'>)}
                                  spids: [269]
                                )
                              ]
                            )
                          ]
                          spids: [260 267 274 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<10.9>}
                            {<10.9.> <Id.Lit_LBracket '['> <0-9> <Id.Lit_RBracket ']'> <Id.Lit_Star '*'>}
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:os_name_)
                                  op: assign_op.Equal
                                  rhs: {(SQ <'Mac OS X Mavericks'>)}
                                  spids: [286]
                                )
                              ]
                            )
                          ]
                          spids: [277 284 291 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<10.10>}
                            {<10.10.> <Id.Lit_LBracket '['> <0-9> <Id.Lit_RBracket ']'> 
                              <Id.Lit_Star '*'>
                            }
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:os_name_)
                                  op: assign_op.Equal
                                  rhs: {(SQ <'Mac OS X Yosemite'>)}
                                  spids: [303]
                                )
                              ]
                            )
                          ]
                          spids: [294 301 308 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<10.11>}
                            {<10.11.> <Id.Lit_LBracket '['> <0-9> <Id.Lit_RBracket ']'> 
                              <Id.Lit_Star '*'>
                            }
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:os_name_)
                                  op: assign_op.Equal
                                  rhs: {(SQ <'Mac OS X El Capitan'>)}
                                  spids: [320]
                                )
                              ]
                            )
                          ]
                          spids: [311 318 325 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<10.12>}
                            {<10.12.> <Id.Lit_LBracket '['> <0-9> <Id.Lit_RBracket ']'> 
                              <Id.Lit_Star '*'>
                            }
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:os_name_)
                                  op: assign_op.Equal
                                  rhs: {(SQ <'macOS Sierra'>)}
                                  spids: [337]
                                )
                              ]
                            )
                          ]
                          spids: [328 335 342 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<10.13>}
                            {<10.13.> <Id.Lit_LBracket '['> <0-9> <Id.Lit_RBracket ']'> 
                              <Id.Lit_Star '*'>
                            }
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:os_name_)
                                  op: assign_op.Equal
                                  rhs: {(SQ <'macOS High Sierra'>)}
                                  spids: [354]
                                )
                              ]
                            )
                          ]
                          spids: [345 352 359 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:os_name_)
                                  op: assign_op.Equal
                                  rhs: {(SQ <macOS>)}
                                  spids: [365]
                                )
                              ]
                            )
                          ]
                          spids: [362 363 370 -1]
                        )
                      ]
                    )
                  ]
                  spids: [161 162 376 -1]
                )
                (case_arm
                  pat_list: [{<FreeBSD>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:os_name_)
                          op: assign_op.Equal
                          rhs: {(SQ <FreeBSD>)}
                          spids: [382]
                        )
                      ]
                    )
                  ]
                  spids: [379 380 387 -1]
                )
                (case_arm
                  pat_list: [{<Linux>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:os_name_)
                          op: assign_op.Equal
                          rhs: {(SQ <Linux>)}
                          spids: [393]
                        )
                      ]
                    )
                  ]
                  spids: [390 391 398 -1]
                )
                (case_arm
                  pat_list: [{<SunOS>}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.Simple
                                  words: [{<grep>} {(SQ <OpenSolaris>)} {</etc/release>}]
                                  redirects: [
                                    (redir.Redir
                                      op: <Id.Redir_Great '>'>
                                      fd: -1
                                      arg_word: {</dev/null>}
                                    )
                                  ]
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:os_name_)
                                  op: assign_op.Equal
                                  rhs: {(SQ <OpenSolaris>)}
                                  spids: [422]
                                )
                              ]
                            )
                          ]
                          spids: [405 419]
                        )
                      ]
                      else_action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:os_name_)
                              op: assign_op.Equal
                              rhs: {(SQ <Solaris>)}
                              spids: [431]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [401 402 440 -1]
                )
              ]
            )
            (C {<echo>} {(${ Id.VSub_Name os_name_)})
            (C {<unset>} {<os_name_>} {<os_system_>} {<os_release_>} {<os_version_>})
          ]
        )
    )
    (command.ShFunction
      name: versions_osVersion
      body: 
        (command.BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:os_version_)
                  op: assign_op.Equal
                  rhs: {(SQ <unrecognized>)}
                  spids: [474]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:os_system_)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name UNAME_S)}
                  spids: [480]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:os_release_)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name UNAME_R)}
                  spids: [486]
                )
              ]
            )
            (command.Case
              to_match: {(${ Id.VSub_Name os_system_)}
              arms: [
                (case_arm
                  pat_list: [{<CYGWIN_NT-> <Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:os_version_)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {<expr>} {(DQ (${ Id.VSub_Name os_release_))} 
                                        {<Id.Lit_Other ':'>} {(SQ <'\\([0-9]*\\.[0-9]\\.[0-9]*\\).*'>)}
                                      )
                                    ]
                                  )
                              )
                            }
                          spids: [506]
                        )
                      ]
                    )
                  ]
                  spids: [501 503 534 -1]
                )
                (case_arm
                  pat_list: [{<Darwin>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:os_version_)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [(C {</usr/bin/sw_vers>} {<-productVersion>})]
                                  )
                              )
                            }
                          spids: [541]
                        )
                      ]
                    )
                  ]
                  spids: [537 538 551 -1]
                )
                (case_arm
                  pat_list: [{<FreeBSD>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:os_version_)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {<expr>} {(DQ (${ Id.VSub_Name os_release_))} 
                                        {<Id.Lit_Other ':'>} {(SQ <'\\([0-9]*\\.[0-9]*\\)-.*'>)}
                                      )
                                    ]
                                  )
                              )
                            }
                          spids: [558]
                        )
                      ]
                    )
                  ]
                  spids: [554 555 584 -1]
                )
                (case_arm
                  pat_list: [{<Linux>}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {<Id.Lit_LBracket '['>} {<-r>} {(DQ (${ Id.VSub_Name LSB_RELEASE))} 
                                  {<Id.Lit_RBracket ']'>}
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {<grep>} {<-q>} {(SQ <'DISTRIB_ID=Ubuntu'>)} 
                                          {(DQ (${ Id.VSub_Name LSB_RELEASE))}
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:os_version_)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Id.Left_Backtick '`'>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (command.Pipeline
                                                        children: [
                                                          (C {<cat>} 
                                                            {(DQ (${ Id.VSub_Name LSB_RELEASE))}
                                                          )
                                                          (C {<awk>} {<-F> <Id.Lit_Equals '='>} 
                                                            {
                                                              (SQ 
                                                                <
'$1~/DISTRIB_DESCRIPTION/{print $2}'
                                                                >
                                                              )
                                                            }
                                                          )
                                                          (C {<sed>} {(SQ <'s/"//g;s/ /-/g'>)})
                                                        ]
                                                        negated: F
                                                      )
                                                    ]
                                                  )
                                              )
                                            }
                                          spids: [633]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [609 626]
                                )
                              ]
                            )
                          ]
                          spids: [591 606]
                        )
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {<Id.Lit_LBracket '['>} {<-r>} {(SQ </etc/redhat-release>)} 
                                  {<Id.Lit_RBracket ']'>}
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:os_version_)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Id.Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [(C {<cat>} {</etc/redhat-release>})]
                                          )
                                      )
                                    }
                                  spids: [693]
                                )
                              ]
                            )
                          ]
                          spids: [677 690]
                        )
                      ]
                    )
                  ]
                  spids: [587 588 706 -1]
                )
                (case_arm
                  pat_list: [{<SunOS>}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.Simple
                                  words: [{<grep>} {(SQ <OpenSolaris>)} {</etc/release>}]
                                  redirects: [
                                    (redir.Redir
                                      op: <Id.Redir_Great '>'>
                                      fd: -1
                                      arg_word: {</dev/null>}
                                    )
                                  ]
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:os_version_)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Id.Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (command.Pipeline
                                                children: [
                                                  (C {<grep>} {(SQ <OpenSolaris>)} {</etc/release>})
                                                  (C {<awk>} {(SQ <'{print $2"("$3")"}'>)})
                                                ]
                                                negated: F
                                              )
                                            ]
                                          )
                                      )
                                    }
                                  spids: [730]
                                )
                              ]
                            )
                          ]
                          spids: [713 727]
                        )
                      ]
                      else_action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:major_)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_Backtick '`'>
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (command.Pipeline
                                            children: [
                                              (C {<echo>} {(DQ (${ Id.VSub_Name os_release_))})
                                              (C {<sed>} {(SQ <'s/[0-9]*\\.\\([0-9]*\\)/\\1/'>)})
                                            ]
                                            negated: F
                                          )
                                        ]
                                      )
                                  )
                                }
                              spids: [754]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:minor_)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_Backtick '`'>
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (command.Pipeline
                                            children: [
                                              (C {<grep>} {<Solaris>} {</etc/release>})
                                              (C {<sed>} {(SQ <'s/[^u]*\\(u[0-9]*\\).*/\\1/'>)})
                                            ]
                                            negated: F
                                          )
                                        ]
                                      )
                                  )
                                }
                              spids: [783]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:os_version_)
                              op: assign_op.Equal
                              rhs: {(DQ (${ Id.VSub_Name major_) (${ Id.VSub_Name minor_))}
                              spids: [808]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [709 710 822 -1]
                )
              ]
            )
            (C {<echo>} {(DQ (${ Id.VSub_Name os_version_))})
            (C {<unset>} {<os_name_>} {<os_release_>} {<os_version_>} {<major_>} {<minor_>})
          ]
        )
    )
    (command.ShFunction
      name: versions_shellVersion
      body: 
        (command.BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shell_)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$1')}
                  spids: [860]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shell_present_)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name FALSE)}
                  spids: [865]
                )
              ]
            )
            (command.Case
              to_match: {(DQ (${ Id.VSub_Name shell_))}
              arms: [
                (case_arm
                  pat_list: [{<ash>}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<Id.Lit_LBracket '['>} {<-x>} {(SQ </bin/busybox>)} {<Id.Lit_RBracket ']'>})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:shell_present_)
                              op: assign_op.Equal
                              rhs: {(${ Id.VSub_Name TRUE)}
                              spids: [898]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [882 883 904 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<Id.Lit_LBracket '['>} {<-x>} {(DQ (${ Id.VSub_Name shell_))} 
                          {<Id.Lit_RBracket ']'>}
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:shell_present_)
                              op: assign_op.Equal
                              rhs: {(${ Id.VSub_Name TRUE)}
                              spids: [925]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [907 908 931 -1]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {<Id.Lit_LBracket '['>} {(${ Id.VSub_Name shell_present_)} {<-eq>} 
                          {(${ Id.VSub_Name FALSE)} {<Id.Lit_RBracket ']'>}
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                  action: [
                    (C {<echo>} {(SQ <'not installed'>)})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {(${ Id.VSub_Name FALSE)}
                    )
                  ]
                  spids: [937 954]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:version_)
                  op: assign_op.Equal
                  rhs: {(SQ )}
                  spids: [975]
                )
              ]
            )
            (command.Case
              to_match: {(${ Id.VSub_Name shell_)}
              arms: [
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'> </sh>}]
                  spids: [989 991 1022 -1]
                )
                (case_arm
                  pat_list: [{<ash>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:version_)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {<versions_shell_ash>} {(DQ (${ Id.VSub_Name shell_))})
                                    ]
                                  )
                              )
                            }
                          spids: [1028]
                        )
                      ]
                    )
                  ]
                  spids: [1025 1026 1041 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'> </bash>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:version_)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {<versions_shell_bash>} {(DQ (${ Id.VSub_Name shell_))})
                                    ]
                                  )
                              )
                            }
                          spids: [1048]
                        )
                      ]
                    )
                  ]
                  spids: [1044 1046 1061 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'> </dash>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:version_)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [(C {<versions_shell_dash>})]
                                  )
                              )
                            }
                          spids: [1081]
                        )
                      ]
                    )
                  ]
                  spids: [1064 1066 1089 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'> </ksh>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:version_)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {<versions_shell_ksh>} {(DQ (${ Id.VSub_Name shell_))})
                                    ]
                                  )
                              )
                            }
                          spids: [1096]
                        )
                      ]
                    )
                  ]
                  spids: [1092 1094 1109 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'> </pdksh>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:version_)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {<versions_shell_pdksh>} {(DQ (${ Id.VSub_Name shell_))})
                                    ]
                                  )
                              )
                            }
                          spids: [1116]
                        )
                      ]
                    )
                  ]
                  spids: [1112 1114 1129 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'> </zsh>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:version_)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {<versions_shell_zsh>} {(DQ (${ Id.VSub_Name shell_))})
                                    ]
                                  )
                              )
                            }
                          spids: [1136]
                        )
                      ]
                    )
                  ]
                  spids: [1132 1134 1149 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:version_)
                          op: assign_op.Equal
                          rhs: {(SQ <invalid>)}
                          spids: [1155]
                        )
                      ]
                    )
                  ]
                  spids: [1152 1153 -1 1161]
                )
              ]
            )
            (C {<echo>} 
              {
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name version_>
                    suffix_op: (suffix_op.Unary op_id:Id.VTest_ColonHyphen arg_word:{<unknown>})
                  )
                )
              }
            )
            (C {<unset>} {<shell_>} {<version_>})
          ]
        )
    )
    (command.ShFunction
      name: versions_shell_ash
      body: 
        (command.BraceGroup
          children: [
            (command.Pipeline
              children: [
                (C {<busybox>} {<--help>})
                (C {<head>} {<-1>})
                (C {<sed>} {(SQ <'s/BusyBox v\\([0-9.]*\\) .*/\\1/'>)})
              ]
              negated: F
            )
          ]
        )
    )
    (command.ShFunction
      name: versions_shell_bash
      body: 
        (command.BraceGroup
          children: [
            (command.Pipeline
              children: [
                (command.Simple
                  words: [{($ Id.VSub_Number '$1')} {<--version>}]
                  redirects: [(redir.Redir op:<Id.Redir_GreatAnd '2>&'> fd:2 arg_word:{<1>})]
                )
                (C {<grep>} {(SQ <'GNU bash'>)})
                (C {<sed>} {(SQ <'s/.*version \\([^ ]*\\).*/\\1/'>)})
              ]
              negated: F
            )
          ]
        )
    )
    (command.ShFunction
      name: versions_shell_dash
      body: 
        (command.BraceGroup
          children: [
            (command.Simple
              words: [{<eval>} {<dpkg>}]
              redirects: [
                (redir.Redir op:<Id.Redir_Great '>'> fd:-1 arg_word:{</dev/null>})
                (redir.Redir op:<Id.Redir_GreatAnd '2>&'> fd:2 arg_word:{<1>})
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {($ Id.VSub_QMark '$?')} {<-eq>} {<127>} 
                  {<Id.Lit_RBracket ']'>}
                )
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.Pipeline
              children: [
                (C {<dpkg>} {<-l>})
                (C {<grep>} {(SQ <' dash '>)})
                (C {<awk>} {(SQ <'{print $3}'>)})
              ]
              negated: F
            )
          ]
        )
    )
    (command.ShFunction
      name: versions_shell_ksh
      body: 
        (command.BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:versions_shell_)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$1')}
                  spids: [1310]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:versions_version_)
                  op: assign_op.Equal
                  rhs: {(SQ )}
                  spids: [1314]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:versions_version_)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_Backtick '`'>
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (command.Simple
                                            words: [
                                              {(${ Id.VSub_Name versions_shell_)}
                                              {<--version>}
                                              {<Id.Lit_Other ':'>}
                                            ]
                                            redirects: [
                                              (redir.Redir
                                                op: <Id.Redir_GreatAnd '2>&'>
                                                fd: 2
                                                arg_word: {<1>}
                                              )
                                            ]
                                          )
                                        ]
                                      )
                                  )
                                }
                              spids: [1326]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:versions_version_)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (command.Pipeline
                                        children: [
                                          (C {<echo>} {(DQ (${ Id.VSub_Name versions_version_))})
                                          (C {<sed>} 
                                            {
                                              (SQ 
                                                <
's/.*\\([0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]\\).*/\\1/'
                                                >
                                              )
                                            }
                                          )
                                        ]
                                        negated: F
                                      )
                                    ]
                                  )
                              )
                            }
                          spids: [1346]
                        )
                      ]
                    )
                  ]
                  spids: [1324 1343]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ (${ Id.VSub_Name versions_version_))} 
                          {<Id.Lit_RBracket ']'>}
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                  action: [
                    (C {<_versions_have_strings>})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:versions_version_)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (command.Pipeline
                                        children: [
                                          (command.Simple
                                            words: [{<strings>} {(DQ (${ Id.VSub_Name versions_shell_))}]
                                            redirects: [
                                              (redir.Redir
                                                op: <Id.Redir_GreatAnd '2>&'>
                                                fd: 2
                                                arg_word: {<1>}
                                              )
                                            ]
                                          )
                                          (C {<grep>} {<Version>})
                                          (C {<sed>} 
                                            {(SQ <'s/^.*Version \\(.*\\)$/\\1/;s/ s+ $$//;s/ /-/g'>)}
                                          )
                                        ]
                                        negated: F
                                      )
                                    ]
                                  )
                              )
                            }
                          spids: [1402]
                        )
                      ]
                    )
                  ]
                  spids: [1381 1396]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ (${ Id.VSub_Name versions_version_))} 
                          {<Id.Lit_RBracket ']'>}
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:versions_version_)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {<versions_shell_pdksh>} 
                                        {(DQ (${ Id.VSub_Name versions_shell_))}
                                      )
                                    ]
                                  )
                              )
                            }
                          spids: [1470]
                        )
                      ]
                    )
                  ]
                  spids: [1452 1467]
                )
              ]
            )
            (C {<echo>} {(DQ (${ Id.VSub_Name versions_version_))})
            (C {<unset>} {<versions_shell_>} {<versions_version_>})
          ]
        )
    )
    (command.ShFunction
      name: versions_shell_pdksh
      body: 
        (command.BraceGroup
          children: [
            (C {<_versions_have_strings>})
            (command.Pipeline
              children: [
                (command.Simple
                  words: [{<strings>} {(DQ ($ Id.VSub_Number '$1'))}]
                  redirects: [(redir.Redir op:<Id.Redir_GreatAnd '2>&'> fd:2 arg_word:{<1>})]
                )
                (C {<grep>} {(SQ <'PD KSH'>)})
                (C {<sed>} {<-e>} {(SQ <'s/.*PD KSH \\(.*\\)/\\1/;s/ /-/g'>)})
              ]
              negated: F
            )
          ]
        )
    )
    (command.ShFunction
      name: versions_shell_zsh
      body: 
        (command.BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:versions_shell_)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$1')}
                  spids: [1555]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:versions_version_)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        command_list: 
                          (command.CommandList
                            children: [
                              (command.Pipeline
                                children: [
                                  (C {<echo>} {(SQ <'echo ${ZSH_VERSION}'>)})
                                  (C {(${ Id.VSub_Name versions_shell_)})
                                ]
                                negated: F
                              )
                            ]
                          )
                      )
                    }
                  spids: [1568]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ (${ Id.VSub_Name versions_version_))} 
                          {<Id.Lit_RBracket ']'>}
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:versions_version_)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (command.Pipeline
                                        children: [
                                          (command.Simple
                                            words: [{(${ Id.VSub_Name versions_shell_)} {<--version>}]
                                            redirects: [
                                              (redir.Redir
                                                op: <Id.Redir_GreatAnd '2>&'>
                                                fd: 2
                                                arg_word: {<1>}
                                              )
                                            ]
                                          )
                                          (C {<awk>} {(SQ <'{print $2}'>)})
                                        ]
                                        negated: F
                                      )
                                    ]
                                  )
                              )
                            }
                          spids: [1604]
                        )
                      ]
                    )
                  ]
                  spids: [1586 1601]
                )
              ]
            )
            (C {<echo>} {(DQ (${ Id.VSub_Name versions_version_))})
            (C {<unset>} {<versions_shell_>} {<versions_version_>})
          ]
        )
    )
    (command.ShFunction
      name: _versions_have_strings
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {(${ Id.VSub_Name __versions_haveStrings)} {<-ne>} 
                  {(${ Id.VSub_Name ERROR)} {<Id.Lit_RBracket ']'>}
                )
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.Simple
                          words: [{<eval>} {<strings>} {</dev/null>}]
                          redirects: [
                            (redir.Redir
                              op: <Id.Redir_Great '>'>
                              fd: -1
                              arg_word: {</dev/null>}
                            )
                            (redir.Redir
                              op: <Id.Redir_GreatAnd '2>&'>
                              fd: 2
                              arg_word: {<1>}
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:__versions_haveStrings)
                          op: assign_op.Equal
                          rhs: {(${ Id.VSub_Name TRUE)}
                          spids: [1695]
                        )
                      ]
                    )
                    (command.ControlFlow token:<Id.ControlFlow_Return return>)
                  ]
                  spids: [1677 1692]
                )
              ]
            )
            (command.Simple
              words: [{<echo>} {(SQ <'WARN: strings not installed. try installing binutils?'>)}]
              redirects: [(redir.Redir op:<Id.Redir_GreatAnd '>&'> fd:-1 arg_word:{<2>})]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:__versions_haveStrings)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name FALSE)}
                  spids: [1718]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: versions_main
      body: 
        (command.BraceGroup
          children: [
            (C {<Id.KW_Set set>} {<-u>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:os_name)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        command_list: (command.CommandList children:[(C {<versions_osName>})])
                      )
                    }
                  spids: [1743]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:os_version)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        command_list: (command.CommandList children:[(C {<versions_osVersion>})])
                      )
                    }
                  spids: [1751]
                )
              ]
            )
            (C {<echo>} 
              {(DQ <'os: '> (${ Id.VSub_Name os_name) <' version: '> (${ Id.VSub_Name os_version))}
            )
            (command.ForEach
              iter_name: shell
              iter_words: [{(${ Id.VSub_Name VERSIONS_SHELLS)}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:shell_version)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {<versions_shellVersion>} {(DQ (${ Id.VSub_Name shell))})
                                    ]
                                  )
                              )
                            }
                          spids: [1788]
                        )
                      ]
                    )
                    (C {<echo>} 
                      {
                        (DQ <'shell: '> (${ Id.VSub_Name shell) <' version: '> 
                          (${ Id.VSub_Name shell_version)
                        )
                      }
                    )
                  ]
                )
            )
          ]
        )
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (C {<Id.Lit_LBracket '['>} {(DQ (${ Id.VSub_Name ARGV0))} {<Id.Lit_Equals '='>} 
                  {(SQ <versions>)} {<Id.Lit_RBracket ']'>}
                )
              terminator: <Id.Op_Semi _>
            )
          ]
          action: [(C {<versions_main>} {(DQ ($ Id.VSub_At '$@'))})]
          spids: [1821 1840]
        )
      ]
    )
  ]
)