(AndOr
  ops: [Op_DAmp]
  children: [
    (FuncDef
      name: _find
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair lhs:(LhsName name:cur) op:Equal spids:[19])
                (assign_pair lhs:(LhsName name:prev) op:Equal spids:[21])
                (assign_pair lhs:(LhsName name:words) op:Equal spids:[23])
                (assign_pair lhs:(LhsName name:cword) op:Equal spids:[25])
              ]
              spids: [17]
            )
            (AndOr
              ops: [Op_DPipe]
              children: [(C {(_init_completion)}) (ControlFlow token:<ControlFlow_Return return>)]
            )
            (Case
              to_match: {($ VSub_Name '$prev')}
              arms: [
                (case_arm
                  pat_list: [{(-maxdepth)} {(-mindepth)}]
                  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 <'{0..9}'>)} {(--)} 
                                              {(DQ ($ VSub_Name '$cur'))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub '$('>
                                      spids: [52 68]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [49]
                        )
                      ]
                      spids: [49]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [43 46 78 16777215]
                )
                (case_arm
                  pat_list: [
                    {(-newer)}
                    {(-anewer)}
                    {(-cnewer)}
                    {(-fls)}
                    {(-fprint)}
                    {(-fprint0)}
                    {(-fprintf)}
                    {(-name)}
                    {(-iname)}
                    {(-lname)}
                    {(-ilname)}
                    {(-wholename)}
                    {(-iwholename)}
                    {(-samefile)}
                  ]
                  action: [
                    (C {(_filedir)})
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [81 110 121 16777215]
                )
                (case_arm
                  pat_list: [{(-fstype)}]
                  action: [
                    (C {(_fstypes)})
                    (AndOr
                      ops: [Op_DAmp]
                      children: [
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {($ VSub_Name '$OSTYPE')}
                              right: {(Lit_Other '*') (bsd) (Lit_Other '*')}
                            )
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:COMPREPLY)
                              op: PlusEqual
                              rhs: 
                                {
                                  (ArrayLiteralPart
                                    words: [
                                      {
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} {(SQ <'local rdonly'>)} {(--)} 
                                                  {(DQ ($ VSub_Name '$cur'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [150 166]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [147]
                            )
                          ]
                          spids: [147]
                        )
                      ]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [124 125 176 16777215]
                )
                (case_arm
                  pat_list: [{(-gid)}]
                  action: [(C {(_gids)}) (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})]
                  spids: [179 180 191 16777215]
                )
                (case_arm
                  pat_list: [{(-group)}]
                  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)}
                                                {(-g)}
                                                {(--)}
                                                {(DQ ($ VSub_Name '$cur'))}
                                              ]
                                              redirects: [
                                                (Redir
                                                  op: <Redir_Great '2>'>
                                                  fd: 2
                                                  arg_word: {(/dev/null)}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub '$('>
                                      spids: [201 215]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [198]
                        )
                      ]
                      spids: [198]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [194 195 225 16777215]
                )
                (case_arm
                  pat_list: [{(-xtype)} {(-type)}]
                  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 <'b c d p f l s'>)} {(--)} 
                                              {(DQ ($ VSub_Name '$cur'))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub '$('>
                                      spids: [237 253]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [234]
                        )
                      ]
                      spids: [234]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [228 231 263 16777215]
                )
                (case_arm
                  pat_list: [{(-uid)}]
                  action: [(C {(_uids)}) (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})]
                  spids: [266 267 278 16777215]
                )
                (case_arm
                  pat_list: [{(-user)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [
                                            (C {(compgen)} {(-u)} {(--)} {(DQ ($ VSub_Name '$cur'))})
                                          ]
                                        )
                                      left_token: <Left_CommandSub '$('>
                                      spids: [288 300]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [285]
                        )
                      ]
                      spids: [285]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [281 282 310 16777215]
                )
                (case_arm
                  pat_list: [{(-exec)} {(-execdir)} {(-ok)} {(-okdir)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:words)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {(words) (Lit_Other '[') (0) (Lit_Other ']')}
                                  {(DQ ($ VSub_Name '$cur'))}
                                ]
                              )
                            }
                          spids: [323]
                        )
                      ]
                      spids: [323]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:cword) op:Equal rhs:{(1)} spids:[336])]
                      spids: [336]
                    )
                    (C {(_command)})
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [313 320 348 16777215]
                )
                (case_arm
                  pat_list: [
                    {(-) (Lit_Other '[') (acm) (Lit_Other ']') (min)}
                    {(-) (Lit_Other '[') (acm) (Lit_Other ']') (KW_Time time)}
                    {(-iname)}
                    {(-lname)}
                    {(-wholename)}
                    {(-iwholename)}
                    {(-lwholename)}
                    {(-ilwholename)}
                    {(-inum)}
                    {(-path)}
                    {(-ipath)}
                    {(-regex)}
                    {(-iregex)}
                    {(-links)}
                    {(-perm)}
                    {(-size)}
                    {(-used)}
                    {(-printf)}
                    {(-context)}
                  ]
                  action: [(ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})]
                  spids: [351 400 412 16777215]
                )
                (case_arm
                  pat_list: [{(-regextype)}]
                  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 <'emacs posix-awk posix-basic posix-egrep\n'> 
                                                  <'                posix-extended'>
                                                )
                                              } {(--)} {(DQ ($ VSub_Name '$cur'))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub '$('>
                                      spids: [422 439]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [419]
                        )
                      ]
                      spids: [419]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [415 416 449 16777215]
                )
              ]
              spids: [36 40 452]
            )
            (AndOr
              ops: [Op_DPipe]
              children: [(C {(_expand)}) (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair lhs:(LhsName name:i) op:Equal spids:[468])
                (assign_pair
                  lhs: (LhsName name:exprfound)
                  op: Equal
                  rhs: {(false)}
                  spids: [470]
                )
              ]
              spids: [466]
            )
            (ForEach
              iter_name: i
              iter_words: [
                {
                  (BracedVarSub
                    token: <VSub_Name words>
                    bracket_op: (WholeArray op_id:Lit_At)
                    spids: [484 489]
                  )
                }
              ]
              do_arg_iter: F
              body: 
                (DoGroup
                  children: [
                    (AndOr
                      ops: [Op_DAmp Op_DAmp]
                      children: [
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {(DQ ($ VSub_Name '$i'))}
                              right: 
                                {(Lit_Other '[') (-) 
                                  (EscapedLiteralPart
                                    token: <Lit_EscapedChar '\\('>
                                  ) (EscapedLiteralPart token:<Lit_EscapedChar '\\)'>) (Lit_Comma ',') 
                                  (EscapedLiteralPart
                                    token: <Lit_EscapedChar '\\!'>
                                  ) (Lit_Other ']') (Lit_Other '*')
                                }
                            )
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:exprfound)
                              op: Equal
                              rhs: {(true)}
                              spids: [516]
                            )
                          ]
                          spids: [516]
                        )
                        (ControlFlow token:<ControlFlow_Break break>)
                      ]
                    )
                  ]
                  spids: [492 524]
                )
              spids: [483 490]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (AndOr
                          ops: [Op_DAmp]
                          children: [
                            (Pipeline
                              children: [(C {($ VSub_Name '$exprfound')})]
                              negated: T
                            )
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_GlobNEqual
                                  left: {(DQ ($ VSub_Name '$cur'))}
                                  right: 
                                    {(Lit_Other '[') (-) 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar '\\('>
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar '\\)'>) (Lit_Comma ',') 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar '\\!'>
                                      ) (Lit_Other ']') (Lit_Other '*')
                                    }
                                )
                            )
                          ]
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(_filedir)} {(-d)})
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [16777215 560]
                )
              ]
              spids: [16777215 573]
            )
            (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 <'-daystart -depth -follow -help\n'> 
                                          <
'        -ignore_readdir_race -maxdepth -mindepth -mindepth -mount\n'
                                          > <'        -noignore_readdir_race -noleaf -regextype -version -warn -nowarn -xdev\n'> 
                                          <
'        -amin -anewer -atime -cmin -cnewer -ctime -empty -executable -false\n'
                                          > <'        -fstype -gid -group -ilname -iname -inum -ipath -iregex -iwholename\n'> 
                                          <
'        -links -lname -mmin -mtime -name -newer -nogroup -nouser -path -perm\n'
                                          > <'        -readable -regex -samefile -size -true -type -uid -used -user\n'> 
                                          <
'        -wholename -writable -xtype -context -delete -exec -execdir -fls\n'
                                          > <'        -fprint -fprint0 -fprintf -ls -ok -okdir -print -print0 -printf -prune\n'> <'        -quit'>
                                        )
                                      } {(--)} {(DQ ($ VSub_Name '$cur'))}
                                    )
                                  ]
                                )
                              left_token: <Left_CommandSub '$('>
                              spids: [584 609]
                            )
                          }
                        ]
                      )
                    }
                  spids: [581]
                )
              ]
              spids: [581]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_ne
                              left: 
                                {
                                  (BracedVarSub
                                    token: <VSub_Name COMPREPLY>
                                    prefix_op: VSub_Pound
                                    bracket_op: (WholeArray op_id:Lit_At)
                                    spids: [619 625]
                                  )
                                }
                              right: {(0)}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_Local
                      flags: [-A]
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:onlyonce)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {(Lit_Other '[') (-daystart) (Lit_Other ']') (Lit_Other '=') (1)}
                                  {(Lit_Other '[') (-depth) (Lit_Other ']') (Lit_Other '=') (1)}
                                  {(Lit_Other '[') (-follow) (Lit_Other ']') (Lit_Other '=') (1)}
                                  {(Lit_Other '[') (-help) (Lit_Other ']') (Lit_Other '=') (1)}
                                  {(Lit_Other '[') (-ignore_readdir_race) (Lit_Other ']') 
                                    (Lit_Other '=') (1)
                                  }
                                  {(Lit_Other '[') (-maxdepth) (Lit_Other ']') (Lit_Other '=') (1)}
                                  {(Lit_Other '[') (-mindepth) (Lit_Other ']') (Lit_Other '=') (1)}
                                  {(Lit_Other '[') (-mount) (Lit_Other ']') (Lit_Other '=') (1)}
                                  {(Lit_Other '[') (-noignore_readdir_race) (Lit_Other ']') 
                                    (Lit_Other '=') (1)
                                  }
                                  {(Lit_Other '[') (-noleaf) (Lit_Other ']') (Lit_Other '=') (1)}
                                  {(Lit_Other '[') (-nowarn) (Lit_Other ']') (Lit_Other '=') (1)}
                                  {(Lit_Other '[') (-regextype) (Lit_Other ']') (Lit_Other '=') (1)}
                                  {(Lit_Other '[') (-version) (Lit_Other ']') (Lit_Other '=') (1)}
                                  {(Lit_Other '[') (-warn) (Lit_Other ']') (Lit_Other '=') (1)}
                                  {(Lit_Other '[') (-xdev) (Lit_Other ']') (Lit_Other '=') (1)}
                                ]
                              )
                            }
                          spids: [657]
                        )
                      ]
                      spids: [653]
                    )
                    (Assignment
                      keyword: Assign_Local
                      pairs: [(assign_pair lhs:(LhsName name:j) op:Equal spids:[758])]
                      spids: [756]
                    )
                    (ForEach
                      iter_name: i
                      iter_words: [
                        {
                          (DQ 
                            (BracedVarSub
                              token: <VSub_Name words>
                              bracket_op: (WholeArray op_id:Lit_At)
                              spids: [768 773]
                            )
                          )
                        }
                      ]
                      do_arg_iter: F
                      body: 
                        (DoGroup
                          children: [
                            (AndOr
                              ops: [Op_DPipe]
                              children: [
                                (DBracket
                                  expr: 
                                    (LogicalAnd
                                      left: (WordTest w:{($ VSub_Name '$i')})
                                      right: 
                                        (WordTest
                                          w: 
                                            {
                                              (BracedVarSub
                                                token: <VSub_Name onlyonce>
                                                bracket_op: 
                                                  (ArrayIndex
                                                    expr: (ArithWord w:{($ VSub_Name '$i')})
                                                  )
                                                spids: [786 791]
                                              )
                                            }
                                        )
                                    )
                                )
                                (ControlFlow
                                  token: <ControlFlow_Continue continue>
                                )
                              ]
                            )
                            (ForEach
                              iter_name: j
                              iter_words: [
                                {
                                  (BracedVarSub
                                    token: <VSub_Name COMPREPLY>
                                    prefix_op: VSub_Bang
                                    bracket_op: (WholeArray op_id:Lit_At)
                                    spids: [806 812]
                                  )
                                }
                              ]
                              do_arg_iter: F
                              body: 
                                (DoGroup
                                  children: [
                                    (AndOr
                                      ops: [Op_DAmp]
                                      children: [
                                        (DBracket
                                          expr: 
                                            (BoolBinary
                                              op_id: BoolBinary_GlobDEqual
                                              left: 
                                                {
                                                  (BracedVarSub
                                                    token: <VSub_Name COMPREPLY>
                                                    bracket_op: (ArrayIndex expr:(ArithVarRef name:j))
                                                    spids: [820 825]
                                                  )
                                                }
                                              right: {($ VSub_Name '$i')}
                                            )
                                        )
                                        (C {(unset)} {(SQ <'COMPREPLY[j]'>)})
                                      ]
                                    )
                                  ]
                                  spids: [815 842]
                                )
                              spids: [805 813]
                            )
                          ]
                          spids: [777 845]
                        )
                      spids: [766 775]
                    )
                  ]
                  spids: [16777215 634]
                )
              ]
              spids: [16777215 848]
            )
            (C {(_filedir)})
            (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
          ]
          spids: [14]
        )
      spids: [10 13]
    )
    (C {(complete)} {(-F)} {(_find)} {(find)})
  ]
)