(command.CommandList
  children: [
    (command.ShFunction
      name: _openssl_sections
      body: 
        (command.BraceGroup
          children: [
            (C {<local>} {<config>} {<f>})
            (command.ForExpr
              init: 
                (arith_expr.BinaryAssign
                  op_id: Id.Arith_Equal
                  left: (sh_lhs_expr.Name name:i)
                  right: (arith_expr.ArithWord w:{<Id.Lit_Digits 2>})
                )
              cond: 
                (arith_expr.Binary
                  op_id: Id.Arith_Less
                  left: (arith_expr.VarRef token:<Id.Lit_ArithVarLike i>)
                  right: (arith_expr.VarRef token:<Id.Lit_ArithVarLike cword>)
                )
              update: (arith_expr.UnaryAssign op_id:Id.Node_PostDPlus child:(sh_lhs_expr.Name name:i))
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobDEqual
                                      left: 
                                        {
                                          (DQ 
                                            (braced_var_sub
                                              token: <Id.VSub_Name words>
                                              bracket_op: 
                                                (bracket_op.ArrayIndex
                                                  expr: 
                                                    (arith_expr.VarRef
                                                      token: <Id.Lit_ArithVarLike i>
                                                    )
                                                )
                                            )
                                          )
                                        }
                                      right: {<-config>}
                                    )
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:config)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (braced_var_sub
                                        token: <Id.VSub_Name words>
                                        bracket_op: 
                                          (bracket_op.ArrayIndex
                                            expr: 
                                              (arith_expr.Binary
                                                op_id: Id.Arith_Plus
                                                left: 
                                                  (arith_expr.VarRef
                                                    token: <Id.Lit_ArithVarLike i>
                                                  )
                                                right: (arith_expr.ArithWord w:{<Id.Lit_Digits 1>})
                                              )
                                          )
                                      )
                                    }
                                  spids: [72]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [49 69]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_z
                              child: {($ Id.VSub_DollarName '$config')}
                            )
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                  action: [
                    (command.ForEach
                      iter_name: f
                      iter_words: [
                        {</etc/ssl/openssl.cnf>}
                        {</etc/pki/tls/openssl.cnf>}
                        {</usr/share/ssl/openssl.cnf>}
                      ]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.AndOr
                              ops: [Id.Op_DAmp Id.Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Unary
                                      op_id: Id.BoolUnary_f
                                      child: {($ Id.VSub_DollarName '$f')}
                                    )
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:config)
                                      op: assign_op.Equal
                                      rhs: {($ Id.VSub_DollarName '$f')}
                                      spids: [139]
                                    )
                                  ]
                                )
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Break break>
                                )
                              ]
                            )
                          ]
                        )
                    )
                  ]
                  spids: [97 108]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.LogicalNot
                      child: 
                        (bool_expr.Unary
                          op_id: Id.BoolUnary_f
                          child: {($ Id.VSub_DollarName '$config')}
                        )
                    )
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<0>}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (sh_array_literal
                        left: <Id.Op_LParen _>
                        words: [
                          {
                            (command_sub
                              left_token: <Id.Left_DollarParen '$('>
                              command_list: 
                                (command.CommandList
                                  children: [
                                    (C {<compgen>} {<-W>} 
                                      {
                                        (DQ 
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (C {<awk>} {(SQ <'/\\[.*\\]/ {print $2}'>)} 
                                                    {($ Id.VSub_DollarName '$config')}
                                                  )
                                                ]
                                              )
                                          )
                                        )
                                      } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                    )
                                  ]
                                )
                            )
                          }
                        ]
                      )
                    }
                  spids: [172]
                )
              ]
            )
          ]
        )
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (command.ShFunction
          name: _openssl
          body: 
            (command.BraceGroup
              children: [
                (C {<local>} {<cur>} {<prev>} {<words>} {<cword>})
                (command.AndOr
                  ops: [Id.Op_DPipe]
                  children: [
                    (C {<_init_completion>})
                    (command.ControlFlow token:<Id.ControlFlow_Return return>)
                  ]
                )
                (C {<local>} {<commands>} {<command>} {<options>} {<formats>})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:commands)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (SQ <'asn1parse ca ciphers crl crl2pkcs7 dgst dh dhparam dsa dsaparam\n'> 
                            <
'        ec ecparam enc engine errstr gendh gendsa genrsa nseq ocsp passwd\n'
                            > <'        pkcs12 pkcs7 pkcs8 prime rand req rsa rsautl s_client s_server s_time\n'> 
                            <
'        sess_id smime speed spkac verify version x509 md2 md4 md5 rmd160 sha\n'
                            > <'        sha1 aes-128-cbc aes-128-ecb aes-192-cbc aes-192-ecb aes-256-cbc\n'> 
                            <
'        aes-256-ecb base64 bf bf-cbc bf-cfb bf-ecb bf-ofb camellia-128-cbc\n'
                            > <'        camellia-128-ecb camellia-192-cbc camellia-192-ecb camellia-256-cbc\n'> 
                            <
'        camellia-256-ecb cast cast-cbc cast5-cbc cast5-cfb cast5-ecb cast5-ofb\n'
                            > <'        des des-cbc des-cfb des-ecb des-ede des-ede-cbc des-ede-cfb des-ede-ofb\n'> 
                            <
'        des-ede3 des-ede3-cbc des-ede3-cfb des-ede3-ofb des-ofb des3 desx rc2\n'
                            > <'        rc2-40-cbc rc2-64-cbc rc2-cbc rc2-cfb rc2-ecb rc2-ofb rc4 rc4-40'>
                          )
                        }
                      spids: [248]
                    )
                  ]
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_eq
                                  left: {($ Id.VSub_DollarName '$cword')}
                                  right: {<1>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {<compgen>} {<-W>} 
                                                  {(DQ ($ Id.VSub_DollarName '$commands'))} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [281]
                            )
                          ]
                        )
                      ]
                      spids: [265 278]
                    )
                  ]
                  else_action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:command)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (braced_var_sub
                                token: <Id.VSub_Name words>
                                bracket_op: 
                                  (bracket_op.ArrayIndex
                                    expr: (arith_expr.ArithWord w:{<Id.Lit_Digits 1>})
                                  )
                              )
                            }
                          spids: [308]
                        )
                      ]
                    )
                    (command.Case
                      to_match: {($ Id.VSub_DollarName '$prev')}
                      arms: [
                        (case_arm
                          pat_list: [
                            {<-CA>}
                            {<-CAfile>}
                            {<-CAkey>}
                            {<-CAserial>}
                            {<-cert>}
                            {<-certfile>}
                            {<-config>}
                            {<-content>}
                            {<-dcert>}
                            {<-dkey>}
                            {<-dhparam>}
                            {<-extfile>}
                            {<-in>}
                            {<-inkey>}
                            {<-kfile>}
                            {<-key>}
                            {<-keyout>}
                            {<-out>}
                            {<-oid>}
                            {<-prvrify>}
                            {<-rand>}
                            {<-recip>}
                            {<-revoke>}
                            {<-sess_in>}
                            {<-sess_out>}
                            {<-spkac>}
                            {<-sign>}
                            {<-signkey>}
                            {<-signer>}
                            {<-signature>}
                            {<-ss_cert>}
                            {<-untrusted>}
                            {<-verify>}
                          ]
                          action: [
                            (C {<_filedir>})
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                              arg_word: {<0>}
                            )
                          ]
                          spids: [324 401 412 -1]
                        )
                        (case_arm
                          pat_list: [{<-outdir>} {<-CApath>}]
                          action: [
                            (C {<_filedir>} {<-d>})
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                              arg_word: {<0>}
                            )
                          ]
                          spids: [415 418 431 -1]
                        )
                        (case_arm
                          pat_list: [{<-name>} {<-crlexts>} {<-extensions>}]
                          action: [
                            (C {<_openssl_sections>})
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                              arg_word: {<0>}
                            )
                          ]
                          spids: [434 439 450 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<-inform>}
                            {<-outform>}
                            {<-keyform>}
                            {<-certform>}
                            {<-CAform>}
                            {<-CAkeyform>}
                            {<-dkeyform>}
                            {<-dcertform>}
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:formats)
                                  op: assign_op.Equal
                                  rhs: {(SQ <'DER PEM'>)}
                                  spids: [473]
                                )
                              ]
                            )
                            (command.Case
                              to_match: {($ Id.VSub_DollarName '$command')}
                              arms: [
                                (case_arm
                                  pat_list: [{<x509>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:formats)
                                          op: assign_op.PlusEqual
                                          rhs: {(DQ <' NET'>)}
                                          spids: [490]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [486 487 496 -1]
                                )
                                (case_arm
                                  pat_list: [{<smime>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:formats)
                                          op: assign_op.PlusEqual
                                          rhs: {(DQ <' SMIME'>)}
                                          spids: [503]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [499 500 509 -1]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {<compgen>} {<-W>} 
                                                      {(DQ ($ Id.VSub_DollarName '$formats'))} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [515]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                              arg_word: {<0>}
                            )
                          ]
                          spids: [453 470 544 -1]
                        )
                        (case_arm
                          pat_list: [{<-connect>}]
                          action: [
                            (C {<_known_hosts_real>} {(DQ ($ Id.VSub_DollarName '$cur'))})
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                              arg_word: {<0>}
                            )
                          ]
                          spids: [547 548 563 -1]
                        )
                        (case_arm
                          pat_list: [{<-starttls>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {<compgen>} {<-W>} {(SQ <'smtp pop3 imap ftp'>)} 
                                                      {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [570]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                              arg_word: {<0>}
                            )
                          ]
                          spids: [566 567 599 -1]
                        )
                        (case_arm
                          pat_list: [{<-cipher>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (command.Simple
                                                      words: [
                                                        {<compgen>}
                                                        {<-W>}
                                                        {
                                                          (DQ 
                                                            (command_sub
                                                              left_token: <Id.Left_DollarParen '$('>
                                                              command_list: 
                                                                (command.CommandList
                                                                  children: [
                                                                    (C {($ Id.VSub_Number '$1')} 
                                                                      {<ciphers>}
                                                                    )
                                                                  ]
                                                                )
                                                            )
                                                          )
                                                        }
                                                        {<-->}
                                                        {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                      ]
                                                      more_env: [
                                                        (env_pair
                                                          name: IFS
                                                          val: {<Id.Lit_Other ':'>}
                                                          spids: [611]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [606]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                              arg_word: {<0>}
                            )
                          ]
                          spids: [602 603 646 -1]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobDEqual
                                      left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                      right: {<-> <Id.Lit_Other '*'>}
                                    )
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                          action: [
                            (command.Case
                              to_match: {($ Id.VSub_DollarName '$command')}
                              arms: [
                                (case_arm
                                  pat_list: [{<asn1parse>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:options)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (SQ 
                                                <
'-inform -in -out -noout -offset -length -i -oid\n'
                                                > <'                        -strparse'>
                                              )
                                            }
                                          spids: [687]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [683 684 694 -1]
                                )
                                (case_arm
                                  pat_list: [{<ca>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:options)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (SQ 
                                                <
'-verbose -config -name -gencrl -revoke -crl_reason\n'
                                                > <'                        -crl_hold -crl_compromise -crl_CA_compromise -crldays\n'> 
                                                <
'                        -crlhours -crlexts -startdate -enddate -days -md\n'
                                                > <'                        -policy -keyfile -key -passin -cert -selfsig -in -out\n'> 
                                                <
'                        -notext -outdir -infiles -spkac -ss_cert -preserveDN\n'
                                                > <'                        -noemailDN -batch -msie_hack -extensions -extfile\n'> 
                                                <
'                        -engine -subj -utf8 -multivalue-rdn'
                                                >
                                              )
                                            }
                                          spids: [701]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [697 698 713 -1]
                                )
                                (case_arm
                                  pat_list: [{<ciphers>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:options)
                                          op: assign_op.Equal
                                          rhs: {(SQ <'-v -ssl2 -ssl3 -tls1'>)}
                                          spids: [720]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [716 717 726 -1]
                                )
                                (case_arm
                                  pat_list: [{<crl>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:options)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (SQ <'-inform -outform -text -in -out -noout -hash\n'> 
                                                <
'                        -issuer -lastupdate -nextupdate -CAfile -CApath'
                                                >
                                              )
                                            }
                                          spids: [733]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [729 730 740 -1]
                                )
                                (case_arm
                                  pat_list: [{<crl2pkcs7>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:options)
                                          op: assign_op.Equal
                                          rhs: {(SQ <'-inform -outform -in -out -print_certs'>)}
                                          spids: [747]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [743 744 753 -1]
                                )
                                (case_arm
                                  pat_list: [{<dgst>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:options)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (SQ 
                                                <
'-md5 -md4 -md2 -sha1 -sha -mdc2 -ripemd160 -dss1\n'
                                                > <'                        -c -d -hex -binary -out -sign -verify -prverify\n'> 
                                                <'                        -signature'>
                                              )
                                            }
                                          spids: [760]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [756 757 768 -1]
                                )
                                (case_arm
                                  pat_list: [{<dsa>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:options)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (SQ 
                                                <
'-inform -outform -in -passin -out -passout -des\n'
                                                > <'                        -des3 -idea -text -noout -modulus -pubin -pubout'>
                                              )
                                            }
                                          spids: [775]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [771 772 782 -1]
                                )
                                (case_arm
                                  pat_list: [{<dsaparam>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:options)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (SQ 
                                                <
'-inform -outform -in -out -noout -text -C -rand\n'
                                                > <'                        -genkey'>
                                              )
                                            }
                                          spids: [789]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [785 786 796 -1]
                                )
                                (case_arm
                                  pat_list: [{<enc>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:options)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (SQ 
                                                <
'-ciphername -in -out -pass -e -d -a -A -k -kfile\n'
                                                > <'                        -S -K -iv -p -P -bufsize -debug'>
                                              )
                                            }
                                          spids: [803]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [799 800 810 -1]
                                )
                                (case_arm
                                  pat_list: [{<dhparam>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:options)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (SQ 
                                                <
'-inform -outform -in -out -dsaparam -noout -text\n'
                                                > <'                        -C -2 -5 -rand'>
                                              )
                                            }
                                          spids: [817]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [813 814 824 -1]
                                )
                                (case_arm
                                  pat_list: [{<gendsa>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:options)
                                          op: assign_op.Equal
                                          rhs: {(SQ <'-out -des -des3 -idea -rand'>)}
                                          spids: [831]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [827 828 837 -1]
                                )
                                (case_arm
                                  pat_list: [{<genrsa>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:options)
                                          op: assign_op.Equal
                                          rhs: {(SQ <'-out -passout -des -des3 -idea -f4 -3 -rand'>)}
                                          spids: [844]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [840 841 850 -1]
                                )
                                (case_arm
                                  pat_list: [{<pkcs7>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:options)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (SQ <'-inform -outform -in -out -print_certs -text\n'> 
                                                <'                        -noout'>
                                              )
                                            }
                                          spids: [857]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [853 854 864 -1]
                                )
                                (case_arm
                                  pat_list: [{<rand>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:options)
                                          op: assign_op.Equal
                                          rhs: {(SQ <'-out -rand -base64'>)}
                                          spids: [871]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [867 868 877 -1]
                                )
                                (case_arm
                                  pat_list: [{<req>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:options)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (SQ 
                                                <
'-inform -outform -in -passin -out -passout -text\n'
                                                > <'                        -noout -verify -modulus -new -rand -newkey -newkey\n'> 
                                                <
'                        -nodes -key -keyform -keyout -md5 -sha1 -md2 -mdc2\n'
                                                > <'                        -config -x509 -days -asn1-kludge -newhdr -extensions\n'> 
                                                <'                        -reqexts section'>
                                              )
                                            }
                                          spids: [884]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [880 881 894 -1]
                                )
                                (case_arm
                                  pat_list: [{<rsa>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:options)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (SQ <'-inform -outform -in -passin -out -passout\n'> 
                                                <
'                        -sgckey -des -des3 -idea -text -noout -modulus -check\n'
                                                > <'                        -pubin -pubout -engine'>
                                              )
                                            }
                                          spids: [901]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [897 898 909 -1]
                                )
                                (case_arm
                                  pat_list: [{<rsautl>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:options)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (SQ <'-in -out -inkey -pubin -certin -sign -verify\n'> 
                                                <
'                        -encrypt -decrypt -pkcs -ssl -raw -hexdump -asn1parse'
                                                >
                                              )
                                            }
                                          spids: [916]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [912 913 923 -1]
                                )
                                (case_arm
                                  pat_list: [{<s_client>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:options)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (SQ 
                                                <'-connect -verify -cert -certform -key -keyform\n'> <'                        -pass -CApath -CAfile -reconnect -pause -showcerts\n'> 
                                                <
'                        -debug -msg -nbio_test -state -nbio -crlf -ign_eof\n'
                                                > <'                        -quiet -ssl2 -ssl3 -tls1 -no_ssl2 -no_ssl3 -no_tls1\n'> 
                                                <
'                        -bugs -cipher -starttls -engine -tlsextdebug\n'
                                                > <'                        -no_ticket -sess_out -sess_in -rand'>
                                              )
                                            }
                                          spids: [930]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [926 927 941 -1]
                                )
                                (case_arm
                                  pat_list: [{<s_server>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:options)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (SQ <'-accept -context -verify -Verify -crl_check\n'> 
                                                <
'                        -crl_check_all -cert -certform -key -keyform -pass\n'
                                                > <'                        -dcert -dcertform -dkey -dkeyform -dpass -dhparam\n'> 
                                                <
'                        -nbio -nbio_test -crlf -debug -msg -state -CApath\n'
                                                > <'                        -CAfile -nocert -cipher -quiet -no_tmp_rsa -ssl2\n'> 
                                                <
'                        -ssl3 -tls1 -no_ssl2 -no_ssl3 -no_tls1 -no_dhe\n'
                                                > <'                        -bugs -hack -www -WWW -HTTP -engine -tlsextdebug\n'> 
                                                <
'                        -no_ticket -id_prefix -rand'
                                                >
                                              )
                                            }
                                          spids: [948]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [944 945 961 -1]
                                )
                                (case_arm
                                  pat_list: [{<s_time>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:options)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (SQ 
                                                <
'-connect -www -cert -key -CApath -CAfile -reuse\n'
                                                > <'                        -new -verify -nbio -time -ssl2 -ssl3 -bugs -cipher'>
                                              )
                                            }
                                          spids: [968]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [964 965 975 -1]
                                )
                                (case_arm
                                  pat_list: [{<sess_id>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:options)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (SQ 
                                                <
'-inform -outform -in -out -text -noout -context ID'
                                                >
                                              )
                                            }
                                          spids: [982]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [978 979 988 -1]
                                )
                                (case_arm
                                  pat_list: [{<smime>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:options)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (SQ 
                                                <
'-encrypt -decrypt -sign -verify -pk7out -des -des3\n'
                                                > <'                        -rc2-40 -rc2-64 -rc2-128 -aes128 -aes192 -aes256 -in\n'> 
                                                <
'                        -certfile -signer -recip -inform -passin -inkey -out\n'
                                                > <'                        -outform -content -to -from -subject -text -rand'>
                                              )
                                            }
                                          spids: [995]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [991 992 1004 -1]
                                )
                                (case_arm
                                  pat_list: [{<speed>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:options)
                                          op: assign_op.Equal
                                          rhs: {(SQ <-engine>)}
                                          spids: [1011]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [1007 1008 1017 -1]
                                )
                                (case_arm
                                  pat_list: [{<verify>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:options)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (SQ <'-CApath -CAfile -purpose -untrusted -help\n'> 
                                                <
'                        -issuer_checks -verbose -certificates'
                                                >
                                              )
                                            }
                                          spids: [1024]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [1020 1021 1031 -1]
                                )
                                (case_arm
                                  pat_list: [{<x509>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:options)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (SQ 
                                                <
'-inform -outform -keyform -CAform -CAkeyform -in\n'
                                                > <'                        -out -serial -hash -subject_hash -issuer_hash -subject\n'> 
                                                <
'                        -issuer -nameopt -email -startdate -enddate -purpose\n'
                                                > <'                        -dates -modulus -fingerprint -alias -noout -trustout\n'> 
                                                <
'                        -clrtrust -clrreject -addtrust -addreject -setalias\n'
                                                > <'                        -days -set_serial -signkey -x509toreq -req -CA -CAkey\n'> 
                                                <
'                        -CAcreateserial -CAserial -text -C -md2 -md5 -sha1\n'
                                                > <'                        -mdc2 -clrext -extfile -extensions -engine'>
                                              )
                                            }
                                          spids: [1038]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [1034 1035 1051 -1]
                                )
                                (case_arm
                                  pat_list: [{<md5>} {<md4>} {<md2>} {<sha1>} {<sha>} {<mdc2>} {<ripemd160>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:options)
                                          op: assign_op.Equal
                                          rhs: {(SQ <'-c -d'>)}
                                          spids: [1070]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [1054 1067 1076 -1]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {<compgen>} {<-W>} 
                                                      {(DQ ($ Id.VSub_DollarName '$options'))} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [1082]
                                )
                              ]
                            )
                          ]
                          spids: [653 669]
                        )
                      ]
                      else_action: [
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$command'))}
                                          right: {<speed>}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (sh_array_literal
                                            left: <Id.Op_LParen _>
                                            words: [
                                              {
                                                (command_sub
                                                  left_token: <Id.Left_DollarParen '$('>
                                                  command_list: 
                                                    (command.CommandList
                                                      children: [
                                                        (C {<compgen>} {<-W>} 
                                                          {
                                                            (SQ <'md2 mdc2 md5 hmac sha1 rmd160\n'> 
                                                              <
'                    idea-cbc rc2-cbc rc5-cbc bf-cbc des-cbc des-ede3 rc4\n'
                                                              > <'                    rsa512 rsa1024 rsa2048 rsa4096 dsa512 dsa1024 dsa2048 idea\n'> 
                                                              <
'                    rc2 des rsa blowfish'
                                                              >
                                                            )
                                                          } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                        )
                                                      ]
                                                    )
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [1127]
                                    )
                                  ]
                                )
                              ]
                              spids: [1109 1124]
                            )
                          ]
                          else_action: [(C {<_filedir>})]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
        )
        (C {<complete>} {<-F>} {<_openssl>} {<-o>} {<default>} {<openssl>})
      ]
    )
  ]
)