(AndOr
  ops: [Op_DAmp]
  children: [
    (FuncDef
      name: _pylint
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair lhs:(LhsName name:cur) op:Equal spids:[13])
                (assign_pair lhs:(LhsName name:prev) op:Equal spids:[15])
                (assign_pair lhs:(LhsName name:words) op:Equal spids:[17])
                (assign_pair lhs:(LhsName name:cword) op:Equal spids:[19])
                (assign_pair lhs:(LhsName name:split) op:Equal spids:[21])
              ]
              spids: [11]
            )
            (AndOr
              ops: [Op_DPipe]
              children: [
                (C {(_init_completion)} {(-s)})
                (ControlFlow token:<ControlFlow_Return return>)
              ]
            )
            (Case
              to_match: {($ VSub_Name '$prev')}
              arms: [
                (case_arm
                  pat_list: [
                    {(--version)}
                    {(-h)}
                    {(--help)}
                    {(--long-help)}
                    {(--help-msg)}
                    {(--init-hook)}
                    {(--ignore)}
                    {(-e)}
                    {(--enable)}
                    {(-d)}
                    {(--disable)}
                    {(--evaluation)}
                    {(--max-line-length)}
                    {(--max-module-lines)}
                    {(--indent-string)}
                    {(--min-similarity-lines)}
                    {(--max-args)}
                    {(--ignored-argument-names)}
                    {(--max-locals)}
                    {(--max-returns)}
                    {(--max-branchs)}
                    {(--max-statements)}
                    {(--max-parents)}
                    {(--max-attributes)}
                    {(--min-public-methods)}
                    {(--max-public-methods)}
                    {(--required-attributes)}
                    {(--bad-functions)}
                    {(--module-rgx)}
                    {(--const-rgx)}
                    {(--class-rgx)}
                    {(--function-rgx)}
                    {(--method-rgx)}
                    {(--attr-rgx)}
                    {(--argument-rgx)}
                    {(--variable-rgx)}
                    {(--inlinevar-rgx)}
                    {(--good-names)}
                    {(--bad-names)}
                    {(--no-docstring-rgx)}
                    {(--dummy-variables-rgx)}
                    {(--additional-builtins)}
                    {(--notes)}
                    {(--ignored-classes)}
                    {(--generated-members)}
                    {(--overgeneral-exceptions)}
                    {(--ignore-iface-methods)}
                    {(--defining-attr-methods)}
                    {(--valid-classmethod-first-arg)}
                    {(--valid-metaclass-classmethod-first-arg)}
                  ]
                  action: [(ControlFlow token:<ControlFlow_Return return>)]
                  spids: [41 164 170 16777215]
                )
                (case_arm
                  pat_list: [{(--rcfile)}]
                  action: [(C {(_filedir)}) (ControlFlow token:<ControlFlow_Return return>)]
                  spids: [173 174 183 16777215]
                )
                (case_arm
                  pat_list: [
                    {(--persistent)}
                    {(-i)}
                    {(--include-ids)}
                    {(-s)}
                    {(--symbols)}
                    {(--files-output)}
                    {(-r)}
                    {(--reports)}
                    {(--comment)}
                    {(--ignore-comments)}
                    {(--ignore-docstrings)}
                    {(--ignore-imports)}
                    {(--init-import)}
                    {(--ignore-mixin-members)}
                    {(--zope)}
                  ]
                  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 <'yes no'>)} {(--)} 
                                              {(DQ ($ VSub_Name '$cur'))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub '$('>
                                      spids: [225 241]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [222]
                        )
                      ]
                      spids: [222]
                    )
                    (ControlFlow token:<ControlFlow_Return return>)
                  ]
                  spids: [186 219 249 16777215]
                )
                (case_arm
                  pat_list: [{(--load-plugins)} {(--deprecated-modules)}]
                  action: [
                    (Sentence
                      child: 
                        (Assignment
                          keyword: Assign_Local
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:prefix)
                              op: Equal
                              rhs: {(EmptyPart)}
                              spids: [260]
                            )
                          ]
                          spids: [258]
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (AndOr
                      ops: [Op_DAmp]
                      children: [
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {($ VSub_Name '$cur')}
                              right: {(Lit_Other '*') (Lit_Comma ',') (Lit_Other '*')}
                            )
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:prefix)
                              op: Equal
                              rhs: 
                                {
                                  (DQ 
                                    (BracedVarSub
                                      token: <VSub_Name cur>
                                      suffix_op: (StringUnary op_id:VOp1_Percent arg_word:{(',*')})
                                      spids: [279 283]
                                    ) (',')
                                  )
                                }
                              spids: [277]
                            )
                          ]
                          spids: [277]
                        )
                      ]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:cur)
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (BracedVarSub
                                  token: <VSub_Name cur>
                                  suffix_op: (StringUnary op_id:VOp1_DPound arg_word:{('*,')})
                                  spids: [290 294]
                                )
                              )
                            }
                          spids: [288]
                        )
                      ]
                      spids: [288]
                    )
                    (C {(_xfunc)} {(python)} {(_python_modules)})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {
                                    (BracedVarSub
                                      token: <VSub_Name COMPREPLY>
                                      bracket_op: (WholeArray op_id:Lit_At)
                                      suffix_op: 
                                        (PatSub
                                          pat: {}
                                          replace: {($ VSub_Name '$prefix')}
                                          do_all: F
                                          do_prefix: T
                                          do_suffix: F
                                        )
                                      spids: [308 317]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [305]
                        )
                      ]
                      spids: [305]
                    )
                    (ControlFlow token:<ControlFlow_Return return>)
                  ]
                  spids: [252 255 325 16777215]
                )
                (case_arm
                  pat_list: [{(-f)} {(--format)}]
                  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 <'text parseable colorized msvs html'>)} {(--)} {(DQ ($ VSub_Name '$cur'))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub '$('>
                                      spids: [337 355]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [334]
                        )
                      ]
                      spids: [334]
                    )
                    (ControlFlow token:<ControlFlow_Return return>)
                  ]
                  spids: [328 331 363 16777215]
                )
                (case_arm
                  pat_list: [{(--import-graph)} {(--ext-import-graph)} {(--int-import-graph)}]
                  action: [(C {(_filedir)} {(dot)}) (ControlFlow token:<ControlFlow_Return return>)]
                  spids: [366 371 382 16777215]
                )
              ]
              spids: [34 38 385]
            )
            (AndOr
              ops: [Op_DAmp]
              children: [(C {($ VSub_Name '$split')}) (ControlFlow token:<ControlFlow_Return return>)]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {($ VSub_Name '$cur')}
                              right: {(-) (Lit_Other '*')}
                            )
                        )
                      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 <'$( _parse_help "$1" --long-help )'>)} {(--)} {(DQ ($ VSub_Name '$cur'))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub '$('>
                                      spids: [417 435]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [414]
                        )
                      ]
                      spids: [414]
                    )
                    (AndOr
                      ops: [Op_DAmp]
                      children: [
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {($ VSub_Name '$COMPREPLY')}
                              right: {(Lit_Other '*') (BoolBinary_GlobEqual '=')}
                            )
                        )
                        (C {(compopt)} {(-o)} {(nospace)})
                      ]
                    )
                    (ControlFlow token:<ControlFlow_Return return>)
                  ]
                  spids: [16777215 411]
                )
              ]
              spids: [16777215 463]
            )
            (C {(_xfunc)} {(python)} {(_python_modules)})
            (C {(_filedir)} {(py)})
          ]
          spids: [8]
        )
      spids: [4 7]
    )
    (C {(complete)} {(-F)} {(_pylint)} {(pylint)})
  ]
)