(command.AndOr
  ops: [Op_DAmp]
  children: [
    (command.FuncDef
      name: _find
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair lhs:(lhs_expr.LhsName name:cur) op:Equal)
                (assign_pair lhs:(lhs_expr.LhsName name:prev) op:Equal)
                (assign_pair lhs:(lhs_expr.LhsName name:words) op:Equal)
                (assign_pair lhs:(lhs_expr.LhsName name:cword) op:Equal)
              ]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(_init_completion)})
                (command.ControlFlow token:<ControlFlow_Return return>)
              ]
            )
            (command.Case
              to_match: {($ VSub_DollarName '$prev')}
              arms: [
                (case_arm
                  pat_list: [{(-maxdepth)} {(-mindepth)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (word_part.ArrayLiteralPart
                                words: [
                                  {
                                    (word_part.CommandSubPart
                                      command_list: 
                                        (command.CommandList
                                          children: [
                                            (C {(compgen)} {(-W)} {(SQ <'{0..9}'>)} {(--)} 
                                              {(DQ ($ VSub_DollarName '$cur'))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub '$('>
                                    )
                                  }
                                ]
                              )
                            }
                        )
                      ]
                    )
                    (command.ControlFlow
                      token: <ControlFlow_Return return>
                      arg_word: {(0)}
                    )
                  ]
                )
                (case_arm
                  pat_list: [
                    {(-newer)}
                    {(-anewer)}
                    {(-cnewer)}
                    {(-fls)}
                    {(-fprint)}
                    {(-fprint0)}
                    {(-fprintf)}
                    {(-name)}
                    {(-iname)}
                    {(-lname)}
                    {(-ilname)}
                    {(-wholename)}
                    {(-iwholename)}
                    {(-samefile)}
                  ]
                  action: [
                    (C {(_filedir)})
                    (command.ControlFlow
                      token: <ControlFlow_Return return>
                      arg_word: {(0)}
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(-fstype)}]
                  action: [
                    (C {(_fstypes)})
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {($ VSub_DollarName '$OSTYPE')}
                              right: {(Lit_Other '*') (bsd) (Lit_Other '*')}
                            )
                        )
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:COMPREPLY)
                              op: PlusEqual
                              rhs: 
                                {
                                  (word_part.ArrayLiteralPart
                                    words: [
                                      {
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} {(SQ <'local rdonly'>)} {(--)} 
                                                  {(DQ ($ VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                        )
                                      }
                                    ]
                                  )
                                }
                            )
                          ]
                        )
                      ]
                    )
                    (command.ControlFlow
                      token: <ControlFlow_Return return>
                      arg_word: {(0)}
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(-gid)}]
                  action: [
                    (C {(_gids)})
                    (command.ControlFlow
                      token: <ControlFlow_Return return>
                      arg_word: {(0)}
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(-group)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (word_part.ArrayLiteralPart
                                words: [
                                  {
                                    (word_part.CommandSubPart
                                      command_list: 
                                        (command.CommandList
                                          children: [
                                            (command.SimpleCommand
                                              words: [
                                                {(compgen)}
                                                {(-g)}
                                                {(--)}
                                                {(DQ ($ VSub_DollarName '$cur'))}
                                              ]
                                              redirects: [
                                                (redir.Redir
                                                  op: <Redir_Great '2>'>
                                                  fd: 2
                                                  arg_word: {(/dev/null)}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub '$('>
                                    )
                                  }
                                ]
                              )
                            }
                        )
                      ]
                    )
                    (command.ControlFlow
                      token: <ControlFlow_Return return>
                      arg_word: {(0)}
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(-xtype)} {(-type)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (word_part.ArrayLiteralPart
                                words: [
                                  {
                                    (word_part.CommandSubPart
                                      command_list: 
                                        (command.CommandList
                                          children: [
                                            (C {(compgen)} {(-W)} {(SQ <'b c d p f l s'>)} {(--)} 
                                              {(DQ ($ VSub_DollarName '$cur'))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub '$('>
                                    )
                                  }
                                ]
                              )
                            }
                        )
                      ]
                    )
                    (command.ControlFlow
                      token: <ControlFlow_Return return>
                      arg_word: {(0)}
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(-uid)}]
                  action: [
                    (C {(_uids)})
                    (command.ControlFlow
                      token: <ControlFlow_Return return>
                      arg_word: {(0)}
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(-user)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (word_part.ArrayLiteralPart
                                words: [
                                  {
                                    (word_part.CommandSubPart
                                      command_list: 
                                        (command.CommandList
                                          children: [
                                            (C {(compgen)} {(-u)} {(--)} {(DQ ($ VSub_DollarName '$cur'))})
                                          ]
                                        )
                                      left_token: <Left_CommandSub '$('>
                                    )
                                  }
                                ]
                              )
                            }
                        )
                      ]
                    )
                    (command.ControlFlow
                      token: <ControlFlow_Return return>
                      arg_word: {(0)}
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(-exec)} {(-execdir)} {(-ok)} {(-okdir)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:words)
                          op: Equal
                          rhs: 
                            {
                              (word_part.ArrayLiteralPart
                                words: [
                                  {(Lit_ArrayLhsOpen 'words[') (0) (Lit_Other ']')}
                                  {(DQ ($ VSub_DollarName '$cur'))}
                                ]
                              )
                            }
                        )
                      ]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:cword) op:Equal rhs:{(1)})]
                    )
                    (C {(_command)})
                    (command.ControlFlow
                      token: <ControlFlow_Return return>
                      arg_word: {(0)}
                    )
                  ]
                )
                (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: [(command.ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})]
                )
                (case_arm
                  pat_list: [{(-regextype)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (word_part.ArrayLiteralPart
                                words: [
                                  {
                                    (word_part.CommandSubPart
                                      command_list: 
                                        (command.CommandList
                                          children: [
                                            (C {(compgen)} {(-W)} 
                                              {
                                                (SQ <'emacs posix-awk posix-basic posix-egrep\n'> 
                                                  <'                posix-extended'>
                                                )
                                              } {(--)} {(DQ ($ VSub_DollarName '$cur'))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub '$('>
                                    )
                                  }
                                ]
                              )
                            }
                        )
                      ]
                    )
                    (command.ControlFlow
                      token: <ControlFlow_Return return>
                      arg_word: {(0)}
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(_expand)})
                (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
              ]
            )
            (command.Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair lhs:(lhs_expr.LhsName name:i) op:Equal)
                (assign_pair
                  lhs: (lhs_expr.LhsName name:exprfound)
                  op: Equal
                  rhs: {(false)}
                )
              ]
            )
            (command.ForEach
              iter_name: i
              iter_words: [
                {
                  (word_part.BracedVarSub
                    token: <VSub_Name words>
                    bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                  )
                }
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.AndOr
                      ops: [Op_DAmp Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {(DQ ($ VSub_DollarName '$i'))}
                              right: 
                                {(Lit_Other '[') (-) 
                                  (word_part.EscapedLiteralPart
                                    token: <Lit_EscapedChar '\\('>
                                  ) (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\)'>) (Lit_Comma ',') 
                                  (word_part.EscapedLiteralPart
                                    token: <Lit_EscapedChar '\\!'>
                                  ) (Lit_Other ']') (Lit_Other '*')
                                }
                            )
                        )
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:exprfound)
                              op: Equal
                              rhs: {(true)}
                            )
                          ]
                        )
                        (command.ControlFlow token:<ControlFlow_Break break>)
                      ]
                    )
                  ]
                )
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Op_DAmp]
                          children: [
                            (command.Pipeline
                              children: [(C {($ VSub_DollarName '$exprfound')})]
                              negated: T
                            )
                            (command.DBracket
                              expr: 
                                (bool_expr.BoolBinary
                                  op_id: BoolBinary_GlobNEqual
                                  left: {(DQ ($ VSub_DollarName '$cur'))}
                                  right: 
                                    {(Lit_Other '[') (-) 
                                      (word_part.EscapedLiteralPart
                                        token: <Lit_EscapedChar '\\('>
                                      ) (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\)'>) (Lit_Comma ',') 
                                      (word_part.EscapedLiteralPart
                                        token: <Lit_EscapedChar '\\!'>
                                      ) (Lit_Other ']') (Lit_Other '*')
                                    }
                                )
                            )
                          ]
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(_filedir)} {(-d)})
                    (command.ControlFlow
                      token: <ControlFlow_Return return>
                      arg_word: {(0)}
                    )
                  ]
                )
              ]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:COMPREPLY)
                  op: Equal
                  rhs: 
                    {
                      (word_part.ArrayLiteralPart
                        words: [
                          {
                            (word_part.CommandSubPart
                              command_list: 
                                (command.CommandList
                                  children: [
                                    (C {(compgen)} {(-W)} 
                                      {
                                        (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_DollarName '$cur'))}
                                    )
                                  ]
                                )
                              left_token: <Left_CommandSub '$('>
                            )
                          }
                        ]
                      )
                    }
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.BoolBinary
                              op_id: BoolBinary_ne
                              left: 
                                {
                                  (word_part.BracedVarSub
                                    token: <VSub_Name COMPREPLY>
                                    prefix_op: VSub_Pound
                                    bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                                  )
                                }
                              right: {(0)}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.Assignment
                      keyword: Assign_Local
                      flags: [-A]
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:onlyonce)
                          op: Equal
                          rhs: 
                            {
                              (word_part.ArrayLiteralPart
                                words: [
                                  {(Lit_Other '[') (-daystart) (Lit_ArrayLhsClose ']=') (1)}
                                  {(Lit_Other '[') (-depth) (Lit_ArrayLhsClose ']=') (1)}
                                  {(Lit_Other '[') (-follow) (Lit_ArrayLhsClose ']=') (1)}
                                  {(Lit_Other '[') (-help) (Lit_ArrayLhsClose ']=') (1)}
                                  {(Lit_Other '[') (-ignore_readdir_race) (Lit_ArrayLhsClose ']=') (1)}
                                  {(Lit_Other '[') (-maxdepth) (Lit_ArrayLhsClose ']=') (1)}
                                  {(Lit_Other '[') (-mindepth) (Lit_ArrayLhsClose ']=') (1)}
                                  {(Lit_Other '[') (-mount) (Lit_ArrayLhsClose ']=') (1)}
                                  {(Lit_Other '[') (-noignore_readdir_race) (Lit_ArrayLhsClose ']=') 
                                    (1)
                                  }
                                  {(Lit_Other '[') (-noleaf) (Lit_ArrayLhsClose ']=') (1)}
                                  {(Lit_Other '[') (-nowarn) (Lit_ArrayLhsClose ']=') (1)}
                                  {(Lit_Other '[') (-regextype) (Lit_ArrayLhsClose ']=') (1)}
                                  {(Lit_Other '[') (-version) (Lit_ArrayLhsClose ']=') (1)}
                                  {(Lit_Other '[') (-warn) (Lit_ArrayLhsClose ']=') (1)}
                                  {(Lit_Other '[') (-xdev) (Lit_ArrayLhsClose ']=') (1)}
                                ]
                              )
                            }
                        )
                      ]
                    )
                    (command.Assignment
                      keyword: Assign_Local
                      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:j) op:Equal)]
                    )
                    (command.ForEach
                      iter_name: i
                      iter_words: [
                        {
                          (DQ 
                            (word_part.BracedVarSub
                              token: <VSub_Name words>
                              bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                            )
                          )
                        }
                      ]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.LogicalAnd
                                      left: (bool_expr.WordTest w:{($ VSub_DollarName '$i')})
                                      right: 
                                        (bool_expr.WordTest
                                          w: 
                                            {
                                              (word_part.BracedVarSub
                                                token: <VSub_Name onlyonce>
                                                bracket_op: 
                                                  (bracket_op.ArrayIndex
                                                    expr: 
                                                      (arith_expr.ArithWord
                                                        w: {($ VSub_DollarName '$i')}
                                                      )
                                                  )
                                              )
                                            }
                                        )
                                    )
                                )
                                (command.ControlFlow
                                  token: <ControlFlow_Continue continue>
                                )
                              ]
                            )
                            (command.ForEach
                              iter_name: j
                              iter_words: [
                                {
                                  (word_part.BracedVarSub
                                    token: <VSub_Name COMPREPLY>
                                    prefix_op: VSub_Bang
                                    bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                                  )
                                }
                              ]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.AndOr
                                      ops: [Op_DAmp]
                                      children: [
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.BoolBinary
                                              op_id: BoolBinary_GlobDEqual
                                              left: 
                                                {
                                                  (word_part.BracedVarSub
                                                    token: <VSub_Name COMPREPLY>
                                                    bracket_op: 
                                                      (bracket_op.ArrayIndex
                                                        expr: 
                                                          (arith_expr.ArithVarRef
                                                            token: <Lit_ArithVarLike j>
                                                          )
                                                      )
                                                  )
                                                }
                                              right: {($ VSub_DollarName '$i')}
                                            )
                                        )
                                        (C {(unset)} {(SQ <'COMPREPLY[j]'>)})
                                      ]
                                    )
                                  ]
                                )
                            )
                          ]
                        )
                    )
                  ]
                )
              ]
            )
            (C {(_filedir)})
            (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
          ]
        )
    )
    (C {(complete)} {(-F)} {(_find)} {(find)})
  ]
)