(CommandList
  children: [
    (FuncDef
      name: _openssl_sections
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair lhs:(LhsName name:config) op:Equal spids:[13])
                (assign_pair lhs:(LhsName name:f) op:Equal spids:[15])
              ]
              spids: [11]
            )
            (ForExpr
              init: 
                (BinaryAssign
                  op_id: Arith_Equal
                  left: (LhsName name:i)
                  right: (ArithWord w:{(Lit_Digits 2)})
                )
              cond: 
                (ArithBinary
                  op_id: Arith_Less
                  left: (ArithVarRef name:i)
                  right: (ArithVarRef name:cword)
                )
              update: (UnaryAssign op_id:Node_PostDPlus child:(LhsName name:i))
              body: 
                (DoGroup
                  children: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (BoolBinary
                                      op_id: BoolBinary_GlobDEqual
                                      left: 
                                        {
                                          (DQ 
                                            (BracedVarSub
                                              token: <VSub_Name words>
                                              bracket_op: (ArrayIndex expr:(ArithVarRef name:i))
                                              spids: [54 59]
                                            )
                                          )
                                        }
                                      right: {(-config)}
                                    )
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:config)
                                  op: Equal
                                  rhs: 
                                    {
                                      (BracedVarSub
                                        token: <VSub_Name words>
                                        bracket_op: 
                                          (ArrayIndex
                                            expr: 
                                              (ArithBinary
                                                op_id: Arith_Plus
                                                left: (ArithVarRef name:i)
                                                right: (ArithWord w:{(Lit_Digits 1)})
                                              )
                                          )
                                        spids: [73 80]
                                      )
                                    }
                                  spids: [72]
                                )
                              ]
                              spids: [72]
                            )
                            (ControlFlow token:<ControlFlow_Break break>)
                          ]
                          spids: [16777215 69]
                        )
                      ]
                      spids: [16777215 86]
                    )
                  ]
                  spids: [46 89]
                )
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: (BoolUnary op_id:BoolUnary_z child:{($ VSub_Name '$config')})
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (ForEach
                      iter_name: f
                      iter_words: [
                        {(/etc/ssl/openssl.cnf)}
                        {(/etc/pki/tls/openssl.cnf)}
                        {(/usr/share/ssl/openssl.cnf)}
                      ]
                      do_arg_iter: False
                      body: 
                        (DoGroup
                          children: [
                            (AndOr
                              children: [
                                (DBracket
                                  expr: (BoolUnary op_id:BoolUnary_f child:{($ VSub_Name '$f')})
                                )
                                (AndOr
                                  children: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:config)
                                          op: Equal
                                          rhs: {($ VSub_Name '$f')}
                                          spids: [139]
                                        )
                                      ]
                                      spids: [139]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Break break>
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          spids: [126 147]
                        )
                      spids: [116 124]
                    )
                  ]
                  spids: [16777215 108]
                )
              ]
              spids: [16777215 150]
            )
            (AndOr
              children: [
                (DBracket
                  expr: (LogicalNot child:(BoolUnary op_id:BoolUnary_f child:{($ VSub_Name '$config')}))
                )
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
              ]
              op_id: Op_DAmp
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:COMPREPLY)
                  op: Equal
                  rhs: 
                    {
                      (ArrayLiteralPart
                        words: [
                          {
                            (CommandSubPart
                              command_list: 
                                (CommandList
                                  children: [
                                    (C {(compgen)} {(-W)} 
                                      {
                                        (DQ 
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (C {(awk)} {(SQ <'/\\[.*\\]/ {print $2}'>)} 
                                                    {($ VSub_Name '$config')}
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub '$('>
                                            spids: [182 192]
                                          )
                                        )
                                      } {(--)} {(DQ ($ VSub_Name '$cur'))}
                                    )
                                  ]
                                )
                              left_token: <Left_CommandSub '$('>
                              spids: [175 203]
                            )
                          }
                        ]
                      )
                    }
                  spids: [172]
                )
              ]
              spids: [172]
            )
          ]
          spids: [8]
        )
      spids: [4 7]
    )
    (AndOr
      children: [
        (FuncDef
          name: _openssl
          body: 
            (BraceGroup
              children: [
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair lhs:(LhsName name:cur) op:Equal spids:[219])
                    (assign_pair lhs:(LhsName name:prev) op:Equal spids:[221])
                    (assign_pair lhs:(LhsName name:words) op:Equal spids:[223])
                    (assign_pair lhs:(LhsName name:cword) op:Equal spids:[225])
                  ]
                  spids: [217]
                )
                (AndOr
                  children: [(C {(_init_completion)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DPipe
                )
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:commands)
                      op: Equal
                      spids: [238]
                    )
                    (assign_pair lhs:(LhsName name:command) op:Equal spids:[240])
                    (assign_pair lhs:(LhsName name:options) op:Equal spids:[242])
                    (assign_pair lhs:(LhsName name:formats) op:Equal spids:[244])
                  ]
                  spids: [236]
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (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'>
                          )
                        }
                      spids: [248]
                    )
                  ]
                  spids: [248]
                )
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_eq
                                  left: {($ VSub_Name '$cword')}
                                  right: {(1)}
                                )
                            )
                          terminator: <Op_Semi ';'>
                        )
                      ]
                      action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:COMPREPLY)
                              op: Equal
                              rhs: 
                                {
                                  (ArrayLiteralPart
                                    words: [
                                      {
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} {(DQ ($ VSub_Name '$commands'))} 
                                                  {(--)} {(DQ ($ VSub_Name '$cur'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [284 300]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [281]
                            )
                          ]
                          spids: [281]
                        )
                      ]
                      spids: [16777215 278]
                    )
                  ]
                  else_action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:command)
                          op: Equal
                          rhs: 
                            {
                              (BracedVarSub
                                token: <VSub_Name words>
                                bracket_op: (ArrayIndex expr:(ArithWord w:{(Lit_Digits 1)}))
                                spids: [309 314]
                              )
                            }
                          spids: [308]
                        )
                      ]
                      spids: [308]
                    )
                    (Case
                      to_match: {($ VSub_Name '$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)})
                            (ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(0)}
                            )
                          ]
                          spids: [324 401 412 16777215]
                        )
                        (case_arm
                          pat_list: [{(-outdir)} {(-CApath)}]
                          action: [
                            (C {(_filedir)} {(-d)})
                            (ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(0)}
                            )
                          ]
                          spids: [415 418 431 16777215]
                        )
                        (case_arm
                          pat_list: [{(-name)} {(-crlexts)} {(-extensions)}]
                          action: [
                            (C {(_openssl_sections)})
                            (ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(0)}
                            )
                          ]
                          spids: [434 439 450 16777215]
                        )
                        (case_arm
                          pat_list: [
                            {(-inform)}
                            {(-outform)}
                            {(-keyform)}
                            {(-certform)}
                            {(-CAform)}
                            {(-CAkeyform)}
                            {(-dkeyform)}
                            {(-dcertform)}
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:formats)
                                  op: Equal
                                  rhs: {(SQ <'DER PEM'>)}
                                  spids: [473]
                                )
                              ]
                              spids: [473]
                            )
                            (Case
                              to_match: {($ VSub_Name '$command')}
                              arms: [
                                (case_arm
                                  pat_list: [{(x509)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:formats)
                                          op: PlusEqual
                                          rhs: {(DQ (' NET'))}
                                          spids: [490]
                                        )
                                      ]
                                      spids: [490]
                                    )
                                  ]
                                  spids: [486 487 496 16777215]
                                )
                                (case_arm
                                  pat_list: [{(smime)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:formats)
                                          op: PlusEqual
                                          rhs: {(DQ (' SMIME'))}
                                          spids: [503]
                                        )
                                      ]
                                      spids: [503]
                                    )
                                  ]
                                  spids: [499 500 509 16777215]
                                )
                              ]
                              spids: [479 483 512]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:COMPREPLY)
                                  op: Equal
                                  rhs: 
                                    {
                                      (ArrayLiteralPart
                                        words: [
                                          {
                                            (CommandSubPart
                                              command_list: 
                                                (CommandList
                                                  children: [
                                                    (C {(compgen)} {(-W)} {(DQ ($ VSub_Name '$formats'))} 
                                                      {(--)} {(DQ ($ VSub_Name '$cur'))}
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub '$('>
                                              spids: [518 534]
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [515]
                                )
                              ]
                              spids: [515]
                            )
                            (ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(0)}
                            )
                          ]
                          spids: [453 470 544 16777215]
                        )
                        (case_arm
                          pat_list: [{(-connect)}]
                          action: [
                            (C {(_known_hosts_real)} {(DQ ($ VSub_Name '$cur'))})
                            (ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(0)}
                            )
                          ]
                          spids: [547 548 563 16777215]
                        )
                        (case_arm
                          pat_list: [{(-starttls)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:COMPREPLY)
                                  op: Equal
                                  rhs: 
                                    {
                                      (ArrayLiteralPart
                                        words: [
                                          {
                                            (CommandSubPart
                                              command_list: 
                                                (CommandList
                                                  children: [
                                                    (C {(compgen)} {(-W)} {(SQ <'smtp pop3 imap ftp'>)} 
                                                      {(--)} {(DQ ($ VSub_Name '$cur'))}
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub '$('>
                                              spids: [573 589]
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [570]
                                )
                              ]
                              spids: [570]
                            )
                            (ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(0)}
                            )
                          ]
                          spids: [566 567 599 16777215]
                        )
                        (case_arm
                          pat_list: [{(-cipher)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:COMPREPLY)
                                  op: Equal
                                  rhs: 
                                    {
                                      (ArrayLiteralPart
                                        words: [
                                          {
                                            (CommandSubPart
                                              command_list: 
                                                (CommandList
                                                  children: [
                                                    (SimpleCommand
                                                      words: [
                                                        {(compgen)}
                                                        {(-W)}
                                                        {
                                                          (DQ 
                                                            (CommandSubPart
                                                              command_list: 
                                                                (CommandList
                                                                  children: [
                                                                    (C {($ VSub_Number '$1')} 
                                                                      {(ciphers)}
                                                                    )
                                                                  ]
                                                                )
                                                              left_token: <Left_CommandSub '$('>
                                                              spids: [619 625]
                                                            )
                                                          )
                                                        }
                                                        {(--)}
                                                        {(DQ ($ VSub_Name '$cur'))}
                                                      ]
                                                      more_env: [
                                                        (env_pair
                                                          name: IFS
                                                          val: {(Lit_Other ':')}
                                                          spids: [611]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub '$('>
                                              spids: [609 636]
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [606]
                                )
                              ]
                              spids: [606]
                            )
                            (ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(0)}
                            )
                          ]
                          spids: [602 603 646 16777215]
                        )
                      ]
                      spids: [317 321 649]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (BoolBinary
                                      op_id: BoolBinary_GlobDEqual
                                      left: {(DQ ($ VSub_Name '$cur'))}
                                      right: {(-) (Lit_Other '*')}
                                    )
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (Case
                              to_match: {($ VSub_Name '$command')}
                              arms: [
                                (case_arm
                                  pat_list: [{(asn1parse)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:options)
                                          op: Equal
                                          rhs: 
                                            {
                                              (SQ 
                                                <
'-inform -in -out -noout -offset -length -i -oid\n'
                                                > <'                        -strparse'>
                                              )
                                            }
                                          spids: [687]
                                        )
                                      ]
                                      spids: [687]
                                    )
                                  ]
                                  spids: [683 684 694 16777215]
                                )
                                (case_arm
                                  pat_list: [{(ca)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (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'
                                                >
                                              )
                                            }
                                          spids: [701]
                                        )
                                      ]
                                      spids: [701]
                                    )
                                  ]
                                  spids: [697 698 713 16777215]
                                )
                                (case_arm
                                  pat_list: [{(ciphers)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:options)
                                          op: Equal
                                          rhs: {(SQ <'-v -ssl2 -ssl3 -tls1'>)}
                                          spids: [720]
                                        )
                                      ]
                                      spids: [720]
                                    )
                                  ]
                                  spids: [716 717 726 16777215]
                                )
                                (case_arm
                                  pat_list: [{(crl)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:options)
                                          op: Equal
                                          rhs: 
                                            {
                                              (SQ <'-inform -outform -text -in -out -noout -hash\n'> 
                                                <
'                        -issuer -lastupdate -nextupdate -CAfile -CApath'
                                                >
                                              )
                                            }
                                          spids: [733]
                                        )
                                      ]
                                      spids: [733]
                                    )
                                  ]
                                  spids: [729 730 740 16777215]
                                )
                                (case_arm
                                  pat_list: [{(crl2pkcs7)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:options)
                                          op: Equal
                                          rhs: {(SQ <'-inform -outform -in -out -print_certs'>)}
                                          spids: [747]
                                        )
                                      ]
                                      spids: [747]
                                    )
                                  ]
                                  spids: [743 744 753 16777215]
                                )
                                (case_arm
                                  pat_list: [{(dgst)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (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'>
                                              )
                                            }
                                          spids: [760]
                                        )
                                      ]
                                      spids: [760]
                                    )
                                  ]
                                  spids: [756 757 768 16777215]
                                )
                                (case_arm
                                  pat_list: [{(dsa)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:options)
                                          op: Equal
                                          rhs: 
                                            {
                                              (SQ 
                                                <
'-inform -outform -in -passin -out -passout -des\n'
                                                > <'                        -des3 -idea -text -noout -modulus -pubin -pubout'>
                                              )
                                            }
                                          spids: [775]
                                        )
                                      ]
                                      spids: [775]
                                    )
                                  ]
                                  spids: [771 772 782 16777215]
                                )
                                (case_arm
                                  pat_list: [{(dsaparam)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:options)
                                          op: Equal
                                          rhs: 
                                            {
                                              (SQ 
                                                <
'-inform -outform -in -out -noout -text -C -rand\n'
                                                > <'                        -genkey'>
                                              )
                                            }
                                          spids: [789]
                                        )
                                      ]
                                      spids: [789]
                                    )
                                  ]
                                  spids: [785 786 796 16777215]
                                )
                                (case_arm
                                  pat_list: [{(enc)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (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'>
                                              )
                                            }
                                          spids: [803]
                                        )
                                      ]
                                      spids: [803]
                                    )
                                  ]
                                  spids: [799 800 810 16777215]
                                )
                                (case_arm
                                  pat_list: [{(dhparam)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:options)
                                          op: Equal
                                          rhs: 
                                            {
                                              (SQ 
                                                <
'-inform -outform -in -out -dsaparam -noout -text\n'
                                                > <'                        -C -2 -5 -rand'>
                                              )
                                            }
                                          spids: [817]
                                        )
                                      ]
                                      spids: [817]
                                    )
                                  ]
                                  spids: [813 814 824 16777215]
                                )
                                (case_arm
                                  pat_list: [{(gendsa)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:options)
                                          op: Equal
                                          rhs: {(SQ <'-out -des -des3 -idea -rand'>)}
                                          spids: [831]
                                        )
                                      ]
                                      spids: [831]
                                    )
                                  ]
                                  spids: [827 828 837 16777215]
                                )
                                (case_arm
                                  pat_list: [{(genrsa)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:options)
                                          op: Equal
                                          rhs: {(SQ <'-out -passout -des -des3 -idea -f4 -3 -rand'>)}
                                          spids: [844]
                                        )
                                      ]
                                      spids: [844]
                                    )
                                  ]
                                  spids: [840 841 850 16777215]
                                )
                                (case_arm
                                  pat_list: [{(pkcs7)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:options)
                                          op: Equal
                                          rhs: 
                                            {
                                              (SQ <'-inform -outform -in -out -print_certs -text\n'> 
                                                <'                        -noout'>
                                              )
                                            }
                                          spids: [857]
                                        )
                                      ]
                                      spids: [857]
                                    )
                                  ]
                                  spids: [853 854 864 16777215]
                                )
                                (case_arm
                                  pat_list: [{(rand)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:options)
                                          op: Equal
                                          rhs: {(SQ <'-out -rand -base64'>)}
                                          spids: [871]
                                        )
                                      ]
                                      spids: [871]
                                    )
                                  ]
                                  spids: [867 868 877 16777215]
                                )
                                (case_arm
                                  pat_list: [{(req)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (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'>
                                              )
                                            }
                                          spids: [884]
                                        )
                                      ]
                                      spids: [884]
                                    )
                                  ]
                                  spids: [880 881 894 16777215]
                                )
                                (case_arm
                                  pat_list: [{(rsa)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (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'>
                                              )
                                            }
                                          spids: [901]
                                        )
                                      ]
                                      spids: [901]
                                    )
                                  ]
                                  spids: [897 898 909 16777215]
                                )
                                (case_arm
                                  pat_list: [{(rsautl)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:options)
                                          op: Equal
                                          rhs: 
                                            {
                                              (SQ <'-in -out -inkey -pubin -certin -sign -verify\n'> 
                                                <
'                        -encrypt -decrypt -pkcs -ssl -raw -hexdump -asn1parse'
                                                >
                                              )
                                            }
                                          spids: [916]
                                        )
                                      ]
                                      spids: [916]
                                    )
                                  ]
                                  spids: [912 913 923 16777215]
                                )
                                (case_arm
                                  pat_list: [{(s_client)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (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'>
                                              )
                                            }
                                          spids: [930]
                                        )
                                      ]
                                      spids: [930]
                                    )
                                  ]
                                  spids: [926 927 941 16777215]
                                )
                                (case_arm
                                  pat_list: [{(s_server)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (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'
                                                >
                                              )
                                            }
                                          spids: [948]
                                        )
                                      ]
                                      spids: [948]
                                    )
                                  ]
                                  spids: [944 945 961 16777215]
                                )
                                (case_arm
                                  pat_list: [{(s_time)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:options)
                                          op: Equal
                                          rhs: 
                                            {
                                              (SQ 
                                                <
'-connect -www -cert -key -CApath -CAfile -reuse\n'
                                                > <'                        -new -verify -nbio -time -ssl2 -ssl3 -bugs -cipher'>
                                              )
                                            }
                                          spids: [968]
                                        )
                                      ]
                                      spids: [968]
                                    )
                                  ]
                                  spids: [964 965 975 16777215]
                                )
                                (case_arm
                                  pat_list: [{(sess_id)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:options)
                                          op: Equal
                                          rhs: 
                                            {
                                              (SQ 
                                                <
'-inform -outform -in -out -text -noout -context ID'
                                                >
                                              )
                                            }
                                          spids: [982]
                                        )
                                      ]
                                      spids: [982]
                                    )
                                  ]
                                  spids: [978 979 988 16777215]
                                )
                                (case_arm
                                  pat_list: [{(smime)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (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'>
                                              )
                                            }
                                          spids: [995]
                                        )
                                      ]
                                      spids: [995]
                                    )
                                  ]
                                  spids: [991 992 1004 16777215]
                                )
                                (case_arm
                                  pat_list: [{(speed)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:options)
                                          op: Equal
                                          rhs: {(SQ <-engine>)}
                                          spids: [1011]
                                        )
                                      ]
                                      spids: [1011]
                                    )
                                  ]
                                  spids: [1007 1008 1017 16777215]
                                )
                                (case_arm
                                  pat_list: [{(verify)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:options)
                                          op: Equal
                                          rhs: 
                                            {
                                              (SQ <'-CApath -CAfile -purpose -untrusted -help\n'> 
                                                <
'                        -issuer_checks -verbose -certificates'
                                                >
                                              )
                                            }
                                          spids: [1024]
                                        )
                                      ]
                                      spids: [1024]
                                    )
                                  ]
                                  spids: [1020 1021 1031 16777215]
                                )
                                (case_arm
                                  pat_list: [{(x509)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (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'>
                                              )
                                            }
                                          spids: [1038]
                                        )
                                      ]
                                      spids: [1038]
                                    )
                                  ]
                                  spids: [1034 1035 1051 16777215]
                                )
                                (case_arm
                                  pat_list: [{(md5)} {(md4)} {(md2)} {(sha1)} {(sha)} {(mdc2)} {(ripemd160)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:options)
                                          op: Equal
                                          rhs: {(SQ <'-c -d'>)}
                                          spids: [1070]
                                        )
                                      ]
                                      spids: [1070]
                                    )
                                  ]
                                  spids: [1054 1067 1076 16777215]
                                )
                              ]
                              spids: [676 680 1079]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:COMPREPLY)
                                  op: Equal
                                  rhs: 
                                    {
                                      (ArrayLiteralPart
                                        words: [
                                          {
                                            (CommandSubPart
                                              command_list: 
                                                (CommandList
                                                  children: [
                                                    (C {(compgen)} {(-W)} {(DQ ($ VSub_Name '$options'))} 
                                                      {(--)} {(DQ ($ VSub_Name '$cur'))}
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub '$('>
                                              spids: [1085 1101]
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [1082]
                                )
                              ]
                              spids: [1082]
                            )
                          ]
                          spids: [16777215 669]
                        )
                      ]
                      else_action: [
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (Sentence
                                  child: 
                                    (DBracket
                                      expr: 
                                        (BoolBinary
                                          op_id: BoolBinary_GlobDEqual
                                          left: {(DQ ($ VSub_Name '$command'))}
                                          right: {(speed)}
                                        )
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:COMPREPLY)
                                      op: Equal
                                      rhs: 
                                        {
                                          (ArrayLiteralPart
                                            words: [
                                              {
                                                (CommandSubPart
                                                  command_list: 
                                                    (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_Name '$cur'))}
                                                        )
                                                      ]
                                                    )
                                                  left_token: <Left_CommandSub '$('>
                                                  spids: [1130 1149]
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [1127]
                                    )
                                  ]
                                  spids: [1127]
                                )
                              ]
                              spids: [16777215 1124]
                            )
                          ]
                          else_action: [(C {(_filedir)})]
                          spids: [1154 1160]
                        )
                      ]
                      spids: [1106 1163]
                    )
                  ]
                  spids: [305 1166]
                )
              ]
              spids: [214]
            )
          spids: [210 213]
        )
        (C {(complete)} {(-F)} {(_openssl)} {(-o)} {(default)} {(openssl)})
      ]
      op_id: Op_DAmp
    )
  ]
)