(command.CommandList
  children: [
    (command.FuncDef
      name: _openssl_sections
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair lhs:(lhs_expr.LhsName name:config) op:Equal)
                (assign_pair lhs:(lhs_expr.LhsName name:f) op:Equal)
              ]
            )
            (command.ForExpr
              init: 
                (arith_expr.BinaryAssign
                  op_id: Arith_Equal
                  left: (lhs_expr.LhsName name:i)
                  right: (arith_expr.ArithWord w:{(Lit_Digits 2)})
                )
              cond: 
                (arith_expr.ArithBinary
                  op_id: Arith_Less
                  left: (arith_expr.ArithVarRef token:<Lit_ArithVarLike i>)
                  right: (arith_expr.ArithVarRef token:<Lit_ArithVarLike cword>)
                )
              update: (arith_expr.UnaryAssign op_id:Node_PostDPlus child:(lhs_expr.LhsName name:i))
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  expr: 
                                    (bool_expr.BoolBinary
                                      op_id: BoolBinary_GlobDEqual
                                      left: 
                                        {
                                          (DQ 
                                            (word_part.BracedVarSub
                                              token: <VSub_Name words>
                                              bracket_op: 
                                                (bracket_op.ArrayIndex
                                                  expr: 
                                                    (arith_expr.ArithVarRef
                                                      token: <Lit_ArithVarLike i>
                                                    )
                                                )
                                            )
                                          )
                                        }
                                      right: {(-config)}
                                    )
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:config)
                                  op: Equal
                                  rhs: 
                                    {
                                      (word_part.BracedVarSub
                                        token: <VSub_Name words>
                                        bracket_op: 
                                          (bracket_op.ArrayIndex
                                            expr: 
                                              (arith_expr.ArithBinary
                                                op_id: Arith_Plus
                                                left: 
                                                  (arith_expr.ArithVarRef
                                                    token: <Lit_ArithVarLike i>
                                                  )
                                                right: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                              )
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Break break>
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.BoolUnary
                              op_id: BoolUnary_z
                              child: {($ VSub_DollarName '$config')}
                            )
                        )
                      terminator: <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: [Op_DAmp Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.BoolUnary
                                      op_id: BoolUnary_f
                                      child: {($ VSub_DollarName '$f')}
                                    )
                                )
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:config)
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$f')}
                                    )
                                  ]
                                )
                                (command.ControlFlow
                                  token: <ControlFlow_Break break>
                                )
                              ]
                            )
                          ]
                        )
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.LogicalNot
                      child: 
                        (bool_expr.BoolUnary
                          op_id: BoolUnary_f
                          child: {($ VSub_DollarName '$config')}
                        )
                    )
                )
                (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
              ]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:COMPREPLY)
                  op: Equal
                  rhs: 
                    {
                      (word_part.ArrayLiteralPart
                        words: [
                          {
                            (word_part.CommandSubPart
                              command_list: 
                                (command.CommandList
                                  children: [
                                    (C {(compgen)} {(-W)} 
                                      {
                                        (DQ 
                                          (word_part.CommandSubPart
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (C {(awk)} {(SQ <'/\\[.*\\]/ {print $2}'>)} 
                                                    {($ VSub_DollarName '$config')}
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub '$('>
                                          )
                                        )
                                      } {(--)} {(DQ ($ VSub_DollarName '$cur'))}
                                    )
                                  ]
                                )
                              left_token: <Left_CommandSub '$('>
                            )
                          }
                        ]
                      )
                    }
                )
              ]
            )
          ]
        )
    )
    (command.AndOr
      ops: [Op_DAmp]
      children: [
        (command.FuncDef
          name: _openssl
          body: 
            (command.BraceGroup
              children: [
                (command.Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair lhs:(lhs_expr.LhsName name:cur) op:Equal)
                    (assign_pair lhs:(lhs_expr.LhsName name:prev) op:Equal)
                    (assign_pair lhs:(lhs_expr.LhsName name:words) op:Equal)
                    (assign_pair lhs:(lhs_expr.LhsName name:cword) op:Equal)
                  ]
                )
                (command.AndOr
                  ops: [Op_DPipe]
                  children: [
                    (C {(_init_completion)})
                    (command.ControlFlow token:<ControlFlow_Return return>)
                  ]
                )
                (command.Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair lhs:(lhs_expr.LhsName name:commands) op:Equal)
                    (assign_pair lhs:(lhs_expr.LhsName name:command) op:Equal)
                    (assign_pair lhs:(lhs_expr.LhsName name:options) op:Equal)
                    (assign_pair lhs:(lhs_expr.LhsName name:formats) op:Equal)
                  ]
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:commands)
                      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'>
                          )
                        }
                    )
                  ]
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.BoolBinary
                                  op_id: BoolBinary_eq
                                  left: {($ VSub_DollarName '$cword')}
                                  right: {(1)}
                                )
                            )
                          terminator: <Op_Semi ';'>
                        )
                      ]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:COMPREPLY)
                              op: Equal
                              rhs: 
                                {
                                  (word_part.ArrayLiteralPart
                                    words: [
                                      {
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {(DQ ($ VSub_DollarName '$commands'))} {(--)} {(DQ ($ VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                        )
                                      }
                                    ]
                                  )
                                }
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  else_action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:command)
                          op: Equal
                          rhs: 
                            {
                              (word_part.BracedVarSub
                                token: <VSub_Name words>
                                bracket_op: 
                                  (bracket_op.ArrayIndex
                                    expr: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                  )
                              )
                            }
                        )
                      ]
                    )
                    (command.Case
                      to_match: {($ 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: <ControlFlow_Return return>
                              arg_word: {(0)}
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-outdir)} {(-CApath)}]
                          action: [
                            (C {(_filedir)} {(-d)})
                            (command.ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(0)}
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-name)} {(-crlexts)} {(-extensions)}]
                          action: [
                            (C {(_openssl_sections)})
                            (command.ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(0)}
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [
                            {(-inform)}
                            {(-outform)}
                            {(-keyform)}
                            {(-certform)}
                            {(-CAform)}
                            {(-CAkeyform)}
                            {(-dkeyform)}
                            {(-dcertform)}
                          ]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:formats)
                                  op: Equal
                                  rhs: {(SQ <'DER PEM'>)}
                                )
                              ]
                            )
                            (command.Case
                              to_match: {($ VSub_DollarName '$command')}
                              arms: [
                                (case_arm
                                  pat_list: [{(x509)}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:formats)
                                          op: PlusEqual
                                          rhs: {(DQ (' NET'))}
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(smime)}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:formats)
                                          op: PlusEqual
                                          rhs: {(DQ (' SMIME'))}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:COMPREPLY)
                                  op: Equal
                                  rhs: 
                                    {
                                      (word_part.ArrayLiteralPart
                                        words: [
                                          {
                                            (word_part.CommandSubPart
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {(compgen)} {(-W)} 
                                                      {(DQ ($ VSub_DollarName '$formats'))} {(--)} {(DQ ($ VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub '$('>
                                            )
                                          }
                                        ]
                                      )
                                    }
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(0)}
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-connect)}]
                          action: [
                            (C {(_known_hosts_real)} {(DQ ($ VSub_DollarName '$cur'))})
                            (command.ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(0)}
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-starttls)}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:COMPREPLY)
                                  op: Equal
                                  rhs: 
                                    {
                                      (word_part.ArrayLiteralPart
                                        words: [
                                          {
                                            (word_part.CommandSubPart
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {(compgen)} {(-W)} {(SQ <'smtp pop3 imap ftp'>)} 
                                                      {(--)} {(DQ ($ VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub '$('>
                                            )
                                          }
                                        ]
                                      )
                                    }
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(0)}
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-cipher)}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:COMPREPLY)
                                  op: Equal
                                  rhs: 
                                    {
                                      (word_part.ArrayLiteralPart
                                        words: [
                                          {
                                            (word_part.CommandSubPart
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (command.SimpleCommand
                                                      words: [
                                                        {(compgen)}
                                                        {(-W)}
                                                        {
                                                          (DQ 
                                                            (word_part.CommandSubPart
                                                              command_list: 
                                                                (command.CommandList
                                                                  children: [
                                                                    (C {($ VSub_Number '$1')} 
                                                                      {(ciphers)}
                                                                    )
                                                                  ]
                                                                )
                                                              left_token: <Left_CommandSub '$('>
                                                            )
                                                          )
                                                        }
                                                        {(--)}
                                                        {(DQ ($ VSub_DollarName '$cur'))}
                                                      ]
                                                      more_env: [
                                                        (env_pair
                                                          name: IFS
                                                          val: {(Lit_Other ':')}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub '$('>
                                            )
                                          }
                                        ]
                                      )
                                    }
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(0)}
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  expr: 
                                    (bool_expr.BoolBinary
                                      op_id: BoolBinary_GlobDEqual
                                      left: {(DQ ($ VSub_DollarName '$cur'))}
                                      right: {(-) (Lit_Other '*')}
                                    )
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.Case
                              to_match: {($ VSub_DollarName '$command')}
                              arms: [
                                (case_arm
                                  pat_list: [{(asn1parse)}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:options)
                                          op: Equal
                                          rhs: 
                                            {
                                              (SQ 
                                                <
'-inform -in -out -noout -offset -length -i -oid\n'
                                                > <'                        -strparse'>
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(ca)}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:options)
                                          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'
                                                >
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(ciphers)}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:options)
                                          op: Equal
                                          rhs: {(SQ <'-v -ssl2 -ssl3 -tls1'>)}
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(crl)}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:options)
                                          op: Equal
                                          rhs: 
                                            {
                                              (SQ <'-inform -outform -text -in -out -noout -hash\n'> 
                                                <
'                        -issuer -lastupdate -nextupdate -CAfile -CApath'
                                                >
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(crl2pkcs7)}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:options)
                                          op: Equal
                                          rhs: {(SQ <'-inform -outform -in -out -print_certs'>)}
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(dgst)}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:options)
                                          op: Equal
                                          rhs: 
                                            {
                                              (SQ 
                                                <
'-md5 -md4 -md2 -sha1 -sha -mdc2 -ripemd160 -dss1\n'
                                                > <'                        -c -d -hex -binary -out -sign -verify -prverify\n'> 
                                                <'                        -signature'>
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(dsa)}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:options)
                                          op: Equal
                                          rhs: 
                                            {
                                              (SQ 
                                                <
'-inform -outform -in -passin -out -passout -des\n'
                                                > <'                        -des3 -idea -text -noout -modulus -pubin -pubout'>
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(dsaparam)}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:options)
                                          op: Equal
                                          rhs: 
                                            {
                                              (SQ 
                                                <
'-inform -outform -in -out -noout -text -C -rand\n'
                                                > <'                        -genkey'>
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(enc)}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:options)
                                          op: Equal
                                          rhs: 
                                            {
                                              (SQ 
                                                <
'-ciphername -in -out -pass -e -d -a -A -k -kfile\n'
                                                > <'                        -S -K -iv -p -P -bufsize -debug'>
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(dhparam)}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:options)
                                          op: Equal
                                          rhs: 
                                            {
                                              (SQ 
                                                <
'-inform -outform -in -out -dsaparam -noout -text\n'
                                                > <'                        -C -2 -5 -rand'>
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(gendsa)}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:options)
                                          op: Equal
                                          rhs: {(SQ <'-out -des -des3 -idea -rand'>)}
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(genrsa)}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:options)
                                          op: Equal
                                          rhs: {(SQ <'-out -passout -des -des3 -idea -f4 -3 -rand'>)}
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(pkcs7)}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:options)
                                          op: Equal
                                          rhs: 
                                            {
                                              (SQ <'-inform -outform -in -out -print_certs -text\n'> 
                                                <'                        -noout'>
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(rand)}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:options)
                                          op: Equal
                                          rhs: {(SQ <'-out -rand -base64'>)}
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(req)}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:options)
                                          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'>
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(rsa)}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:options)
                                          op: Equal
                                          rhs: 
                                            {
                                              (SQ <'-inform -outform -in -passin -out -passout\n'> 
                                                <
'                        -sgckey -des -des3 -idea -text -noout -modulus -check\n'
                                                > <'                        -pubin -pubout -engine'>
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(rsautl)}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:options)
                                          op: Equal
                                          rhs: 
                                            {
                                              (SQ <'-in -out -inkey -pubin -certin -sign -verify\n'> 
                                                <
'                        -encrypt -decrypt -pkcs -ssl -raw -hexdump -asn1parse'
                                                >
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(s_client)}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:options)
                                          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'>
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(s_server)}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:options)
                                          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'
                                                >
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(s_time)}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:options)
                                          op: Equal
                                          rhs: 
                                            {
                                              (SQ 
                                                <
'-connect -www -cert -key -CApath -CAfile -reuse\n'
                                                > <'                        -new -verify -nbio -time -ssl2 -ssl3 -bugs -cipher'>
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(sess_id)}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:options)
                                          op: Equal
                                          rhs: 
                                            {
                                              (SQ 
                                                <
'-inform -outform -in -out -text -noout -context ID'
                                                >
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(smime)}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:options)
                                          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'>
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(speed)}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:options)
                                          op: Equal
                                          rhs: {(SQ <-engine>)}
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(verify)}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:options)
                                          op: Equal
                                          rhs: 
                                            {
                                              (SQ <'-CApath -CAfile -purpose -untrusted -help\n'> 
                                                <
'                        -issuer_checks -verbose -certificates'
                                                >
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(x509)}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:options)
                                          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'>
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(md5)} {(md4)} {(md2)} {(sha1)} {(sha)} {(mdc2)} {(ripemd160)}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:options)
                                          op: Equal
                                          rhs: {(SQ <'-c -d'>)}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:COMPREPLY)
                                  op: Equal
                                  rhs: 
                                    {
                                      (word_part.ArrayLiteralPart
                                        words: [
                                          {
                                            (word_part.CommandSubPart
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {(compgen)} {(-W)} 
                                                      {(DQ ($ VSub_DollarName '$options'))} {(--)} {(DQ ($ VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub '$('>
                                            )
                                          }
                                        ]
                                      )
                                    }
                                )
                              ]
                            )
                          ]
                        )
                      ]
                      else_action: [
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.BoolBinary
                                          op_id: BoolBinary_GlobDEqual
                                          left: {(DQ ($ VSub_DollarName '$command'))}
                                          right: {(speed)}
                                        )
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:COMPREPLY)
                                      op: Equal
                                      rhs: 
                                        {
                                          (word_part.ArrayLiteralPart
                                            words: [
                                              {
                                                (word_part.CommandSubPart
                                                  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 ($ VSub_DollarName '$cur'))}
                                                        )
                                                      ]
                                                    )
                                                  left_token: <Left_CommandSub '$('>
                                                )
                                              }
                                            ]
                                          )
                                        }
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                          else_action: [(C {(_filedir)})]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
        )
        (C {(complete)} {(-F)} {(_openssl)} {(-o)} {(default)} {(openssl)})
      ]
    )
  ]
)