(CommandList
  children: [
    (FuncDef
      name: _bluetooth_adresses
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolUnary
                              op_id: BoolUnary_n
                              child: 
                                {
                                  (BracedVarSub
                                    token: <VSub_Name COMP_BLUETOOTH_SCAN>
                                    suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{})
                                    spids: [17 20]
                                  )
                                }
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:COMPREPLY)
                          op: PlusEqual
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [
                                            (C {(compgen)} {(-W)} 
                                              {
                                                (DQ 
                                                  (CommandSubPart
                                                    command_list: 
                                                      (CommandList
                                                        children: [
                                                          (Pipeline
                                                            children: [
                                                              (C {(hcitool)} {(scan)})
                                                              (C {(awk)} {(SQ <"/^\\t/{print $1}">)})
                                                            ]
                                                            negated: False
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_CommandSub "$(">
                                                    spids: [38 54]
                                                  )
                                                )
                                              } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub "$(">
                                      spids: [31 63]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [28]
                        )
                      ]
                      spids: [28]
                    )
                  ]
                  spids: [-1 25]
                )
              ]
              spids: [-1 68]
            )
          ]
          spids: [8]
        )
      spids: [4 7]
    )
    (FuncDef
      name: _bluetooth_devices
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:COMPREPLY)
                  op: PlusEqual
                  rhs: 
                    {
                      (ArrayLiteralPart
                        words: [
                          {
                            (CommandSubPart
                              command_list: 
                                (CommandList
                                  children: [
                                    (C {(compgen)} {(-W)} 
                                      {
                                        (DQ 
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (Pipeline
                                                    children: [
                                                      (C {(hcitool)} {(dev)})
                                                      (C {(awk)} {(SQ <"/^\\t/{print $1}">)})
                                                    ]
                                                    negated: False
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub "$(">
                                            spids: [90 106]
                                          )
                                        )
                                      } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                    )
                                  ]
                                )
                              left_token: <Left_CommandSub "$(">
                              spids: [83 115]
                            )
                          }
                        ]
                      )
                    }
                  spids: [80]
                )
              ]
              spids: [80]
            )
          ]
          spids: [77]
        )
      spids: [73 76]
    )
    (FuncDef
      name: _bluetooth_services
      body: 
        (BraceGroup
          children: [
            (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 <"DID SP DUN LAN FAX OPUSH FTP HS HF HFAG SAP NAP\n"> 
                                          <
"        GN PANU HCRP HID CIP A2SRC A2SNK AVRCT AVRTG UDIUE UDITE SYNCML"
                                          >
                                        )
                                      } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                    )
                                  ]
                                )
                              left_token: <Left_CommandSub "$(">
                              spids: [132 151]
                            )
                          }
                        ]
                      )
                    }
                  spids: [129]
                )
              ]
              spids: [129]
            )
          ]
          spids: [126]
        )
      spids: [122 125]
    )
    (FuncDef
      name: _bluetooth_packet_types
      body: 
        (BraceGroup
          children: [
            (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 <"DM1 DM3 DM5 DH1 DH3 DH5 HV1 HV2 HV3">)} 
                                      {(--)} {(DQ ($ VSub_Name "$cur"))}
                                    )
                                  ]
                                )
                              left_token: <Left_CommandSub "$(">
                              spids: [168 186]
                            )
                          }
                        ]
                      )
                    }
                  spids: [165]
                )
              ]
              spids: [165]
            )
          ]
          spids: [162]
        )
      spids: [158 161]
    )
    (AndOr
      children: [
        (FuncDef
          name: _hcitool
          body: 
            (BraceGroup
              children: [
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair lhs:(LhsName name:cur) op:Equal spids:[202])
                    (assign_pair lhs:(LhsName name:prev) op:Equal spids:[204])
                    (assign_pair lhs:(LhsName name:words) op:Equal spids:[206])
                    (assign_pair lhs:(LhsName name:cword) op:Equal spids:[208])
                    (assign_pair lhs:(LhsName name:split) op:Equal spids:[210])
                  ]
                  spids: [200]
                )
                (AndOr
                  children: [
                    (C {(_init_completion)} {(-s)})
                    (ControlFlow token:<ControlFlow_Return return>)
                  ]
                  op_id: Op_DPipe
                )
                (Case
                  to_match: {($ VSub_Name "$prev")}
                  arms: [
                    (case_arm
                      pat_list: [{(-i)}]
                      action: [
                        (C {(_bluetooth_devices)})
                        (ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [230 231 242 -1]
                    )
                    (case_arm
                      pat_list: [{(--role)}]
                      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 <"m s">)} {(--)} 
                                                  {(DQ ($ VSub_Name "$cur"))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [252 268]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [249]
                            )
                          ]
                          spids: [249]
                        )
                        (ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [245 246 278 -1]
                    )
                    (case_arm
                      pat_list: [{(--pkt-type)}]
                      action: [
                        (C {(_bluetooth_packet_types)})
                        (ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [281 282 293 -1]
                    )
                  ]
                  spids: [223 227 296]
                )
                (AndOr
                  children: [
                    (C {($ VSub_Name "$split")})
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  op_id: Op_DAmp
                )
                (Assignment
                  keyword: Assign_Local
                  pairs: [(assign_pair lhs:(LhsName name:arg) op:Equal spids:[312])]
                  spids: [310]
                )
                (C {(_get_first_arg)})
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: (BoolUnary op_id:BoolUnary_z child:{($ VSub_Name "$arg")})
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (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: [
                                (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\" )">)} {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                        )
                                                      ]
                                                    )
                                                  left_token: <Left_CommandSub "$(">
                                                  spids: [354 370]
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [351]
                                    )
                                  ]
                                  spids: [351]
                                )
                              ]
                              spids: [-1 348]
                            )
                          ]
                          else_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 
                                                          <
"dev inq scan name info spinq epinq cmd\n"
                                                          > <"                con cc dc sr cpt rssi lq tpl afh lst auth enc key clkoff\n"> 
                                                          <"                clock">
                                                        )
                                                      } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub "$(">
                                              spids: [381 399]
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [378]
                                )
                              ]
                              spids: [378]
                            )
                          ]
                          spids: [375 404]
                        )
                      ]
                      spids: [-1 329]
                    )
                  ]
                  else_action: [
                    (Assignment
                      keyword: Assign_Local
                      pairs: [(assign_pair lhs:(LhsName name:args) op:Equal spids:[412])]
                      spids: [410]
                    )
                    (Case
                      to_match: {($ VSub_Name "$arg")}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(name)}
                            {(info)}
                            {(dc)}
                            {(rssi)}
                            {(lq)}
                            {(afh)}
                            {(auth)}
                            {(key)}
                            {(clkoff)}
                            {(lst)}
                          ]
                          action: [
                            (C {(_count_args)})
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (DBracket
                                          expr: 
                                            (BoolBinary
                                              op_id: BoolBinary_eq
                                              left: {($ VSub_Name "$args")}
                                              right: {(2)}
                                            )
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [(C {(_bluetooth_adresses)})]
                                  spids: [-1 460]
                                )
                              ]
                              spids: [-1 466]
                            )
                          ]
                          spids: [422 441 469 -1]
                        )
                        (case_arm
                          pat_list: [{(cc)}]
                          action: [
                            (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: [
                                    (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 <"--role --pkt-type">)} {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                            )
                                                          ]
                                                        )
                                                      left_token: <Left_CommandSub "$(">
                                                      spids: [498 514]
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [495]
                                        )
                                      ]
                                      spids: [495]
                                    )
                                  ]
                                  spids: [-1 492]
                                )
                              ]
                              else_action: [
                                (C {(_count_args)})
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (Sentence
                                          child: 
                                            (DBracket
                                              expr: 
                                                (BoolBinary
                                                  op_id: BoolBinary_eq
                                                  left: {($ VSub_Name "$args")}
                                                  right: {(2)}
                                                )
                                            )
                                          terminator: <Op_Semi ";">
                                        )
                                      ]
                                      action: [(C {(_bluetooth_adresses)})]
                                      spids: [-1 538]
                                    )
                                  ]
                                  spids: [-1 544]
                                )
                              ]
                              spids: [519 547]
                            )
                          ]
                          spids: [472 473 550 -1]
                        )
                        (case_arm
                          pat_list: [{(sr)}]
                          action: [
                            (C {(_count_args)})
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (DBracket
                                          expr: 
                                            (BoolBinary
                                              op_id: BoolBinary_eq
                                              left: {($ VSub_Name "$args")}
                                              right: {(2)}
                                            )
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [(C {(_bluetooth_adresses)})]
                                  spids: [-1 573]
                                )
                              ]
                              else_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 <"master slave">)} 
                                                          {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                        )
                                                      ]
                                                    )
                                                  left_token: <Left_CommandSub "$(">
                                                  spids: [585 601]
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [582]
                                    )
                                  ]
                                  spids: [582]
                                )
                              ]
                              spids: [579 606]
                            )
                          ]
                          spids: [553 554 609 -1]
                        )
                        (case_arm
                          pat_list: [{(cpt)}]
                          action: [
                            (C {(_count_args)})
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (DBracket
                                          expr: 
                                            (BoolBinary
                                              op_id: BoolBinary_eq
                                              left: {($ VSub_Name "$args")}
                                              right: {(2)}
                                            )
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [(C {(_bluetooth_adresses)})]
                                  spids: [-1 632]
                                )
                              ]
                              else_action: [(C {(_bluetooth_packet_types)})]
                              spids: [638 644]
                            )
                          ]
                          spids: [612 613 647 -1]
                        )
                        (case_arm
                          pat_list: [{(tpl)} {(enc)} {(clock)}]
                          action: [
                            (C {(_count_args)})
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (DBracket
                                          expr: 
                                            (BoolBinary
                                              op_id: BoolBinary_eq
                                              left: {($ VSub_Name "$args")}
                                              right: {(2)}
                                            )
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [(C {(_bluetooth_adresses)})]
                                  spids: [-1 674]
                                )
                              ]
                              else_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 1">)} {(--)} 
                                                          {(DQ ($ VSub_Name "$cur"))}
                                                        )
                                                      ]
                                                    )
                                                  left_token: <Left_CommandSub "$(">
                                                  spids: [686 702]
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [683]
                                    )
                                  ]
                                  spids: [683]
                                )
                              ]
                              spids: [680 707]
                            )
                          ]
                          spids: [650 655 710 -1]
                        )
                      ]
                      spids: [415 419 713]
                    )
                  ]
                  spids: [407 716]
                )
              ]
              spids: [197]
            )
          spids: [193 196]
        )
        (C {(complete)} {(-F)} {(_hcitool)} {(hcitool)})
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (FuncDef
          name: _sdptool
          body: 
            (BraceGroup
              children: [
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair lhs:(LhsName name:cur) op:Equal spids:[740])
                    (assign_pair lhs:(LhsName name:prev) op:Equal spids:[742])
                    (assign_pair lhs:(LhsName name:words) op:Equal spids:[744])
                    (assign_pair lhs:(LhsName name:cword) op:Equal spids:[746])
                    (assign_pair lhs:(LhsName name:split) op:Equal spids:[748])
                  ]
                  spids: [738]
                )
                (AndOr
                  children: [
                    (C {(_init_completion)} {(-s)})
                    (ControlFlow token:<ControlFlow_Return return>)
                  ]
                  op_id: Op_DPipe
                )
                (Case
                  to_match: {($ VSub_Name "$prev")}
                  arms: [
                    (case_arm
                      pat_list: [{(--bdaddr)}]
                      action: [
                        (C {(_bluetooth_adresses)})
                        (ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [768 769 780 -1]
                    )
                  ]
                  spids: [761 765 783]
                )
                (AndOr
                  children: [
                    (C {($ VSub_Name "$split")})
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  op_id: Op_DAmp
                )
                (Assignment
                  keyword: Assign_Local
                  pairs: [(assign_pair lhs:(LhsName name:arg) op:Equal spids:[799])]
                  spids: [797]
                )
                (C {(_get_first_arg)})
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: (BoolUnary op_id:BoolUnary_z child:{($ VSub_Name "$arg")})
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (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: [
                                (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\" )">)} {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                        )
                                                      ]
                                                    )
                                                  left_token: <Left_CommandSub "$(">
                                                  spids: [841 857]
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [838]
                                    )
                                  ]
                                  spids: [838]
                                )
                              ]
                              spids: [-1 835]
                            )
                          ]
                          else_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 <"search browse records add del get\n"> 
                                                          <"                setattr setseq">
                                                        )
                                                      } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub "$(">
                                              spids: [868 885]
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [865]
                                )
                              ]
                              spids: [865]
                            )
                          ]
                          spids: [862 890]
                        )
                      ]
                      spids: [-1 816]
                    )
                  ]
                  else_action: [
                    (Case
                      to_match: {($ VSub_Name "$arg")}
                      arms: [
                        (case_arm
                          pat_list: [{(search)}]
                          action: [
                            (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: [
                                    (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 <"--bdaddr --tree --raw --xml">)} {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                            )
                                                          ]
                                                        )
                                                      left_token: <Left_CommandSub "$(">
                                                      spids: [929 947]
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [926]
                                        )
                                      ]
                                      spids: [926]
                                    )
                                  ]
                                  spids: [-1 923]
                                )
                              ]
                              else_action: [(C {(_bluetooth_services)})]
                              spids: [952 958]
                            )
                          ]
                          spids: [903 904 961 -1]
                        )
                        (case_arm
                          pat_list: [{(browse)} {(records)}]
                          action: [
                            (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: [
                                    (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 <"--tree --raw --xml">)} {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                            )
                                                          ]
                                                        )
                                                      left_token: <Left_CommandSub "$(">
                                                      spids: [992 1008]
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [989]
                                        )
                                      ]
                                      spids: [989]
                                    )
                                  ]
                                  spids: [-1 986]
                                )
                              ]
                              else_action: [(C {(_bluetooth_adresses)})]
                              spids: [1013 1019]
                            )
                          ]
                          spids: [964 967 1022 -1]
                        )
                        (case_arm
                          pat_list: [{(add)}]
                          action: [
                            (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: [
                                    (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 <"--handle --channel">)} {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                            )
                                                          ]
                                                        )
                                                      left_token: <Left_CommandSub "$(">
                                                      spids: [1051 1067]
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [1048]
                                        )
                                      ]
                                      spids: [1048]
                                    )
                                  ]
                                  spids: [-1 1045]
                                )
                              ]
                              else_action: [(C {(_bluetooth_services)})]
                              spids: [1072 1078]
                            )
                          ]
                          spids: [1025 1026 1081 -1]
                        )
                        (case_arm
                          pat_list: [{(get)}]
                          action: [
                            (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: [
                                    (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 <"--bdaddr --tree --raw --xml">)} {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                            )
                                                          ]
                                                        )
                                                      left_token: <Left_CommandSub "$(">
                                                      spids: [1110 1128]
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [1107]
                                        )
                                      ]
                                      spids: [1107]
                                    )
                                  ]
                                  spids: [-1 1104]
                                )
                              ]
                              spids: [-1 1133]
                            )
                          ]
                          spids: [1084 1085 1136 -1]
                        )
                      ]
                      spids: [896 900 1139]
                    )
                  ]
                  spids: [893 1142]
                )
              ]
              spids: [735]
            )
          spids: [731 734]
        )
        (C {(complete)} {(-F)} {(_sdptool)} {(sdptool)})
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (FuncDef
          name: _l2ping
          body: 
            (BraceGroup
              children: [
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair lhs:(LhsName name:cur) op:Equal spids:[1166])
                    (assign_pair lhs:(LhsName name:prev) op:Equal spids:[1168])
                    (assign_pair lhs:(LhsName name:words) op:Equal spids:[1170])
                    (assign_pair lhs:(LhsName name:cword) op:Equal spids:[1172])
                  ]
                  spids: [1164]
                )
                (AndOr
                  children: [(C {(_init_completion)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DPipe
                )
                (Case
                  to_match: {($ VSub_Name "$prev")}
                  arms: [
                    (case_arm
                      pat_list: [{(-i)}]
                      action: [
                        (C {(_bluetooth_devices)})
                        (ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [1190 1191 1202 -1]
                    )
                    (case_arm
                      pat_list: [{(-s)} {(-c)} {(-t)} {(-d)}]
                      action: [(ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})]
                      spids: [1205 1212 1220 -1]
                    )
                  ]
                  spids: [1183 1187 1223]
                )
                (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: [
                        (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_usage \"$1\" )">)} 
                                                  {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [1249 1265]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1246]
                            )
                          ]
                          spids: [1246]
                        )
                      ]
                      spids: [-1 1243]
                    )
                  ]
                  else_action: [(C {(_bluetooth_adresses)})]
                  spids: [1270 1276]
                )
              ]
              spids: [1161]
            )
          spids: [1157 1160]
        )
        (C {(complete)} {(-F)} {(_l2ping)} {(l2ping)})
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (FuncDef
          name: _rfcomm
          body: 
            (BraceGroup
              children: [
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair lhs:(LhsName name:cur) op:Equal spids:[1300])
                    (assign_pair lhs:(LhsName name:prev) op:Equal spids:[1302])
                    (assign_pair lhs:(LhsName name:words) op:Equal spids:[1304])
                    (assign_pair lhs:(LhsName name:cword) op:Equal spids:[1306])
                  ]
                  spids: [1298]
                )
                (AndOr
                  children: [(C {(_init_completion)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DPipe
                )
                (Case
                  to_match: {($ VSub_Name "$prev")}
                  arms: [
                    (case_arm
                      pat_list: [{(-f)} {(--config)}]
                      action: [
                        (C {(_filedir)})
                        (ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [1324 1327 1338 -1]
                    )
                    (case_arm
                      pat_list: [{(-i)}]
                      action: [
                        (C {(_bluetooth_devices)})
                        (C {(_bluetooth_adresses)})
                        (ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [1341 1342 1356 -1]
                    )
                  ]
                  spids: [1317 1321 1359]
                )
                (Assignment
                  keyword: Assign_Local
                  pairs: [(assign_pair lhs:(LhsName name:arg) op:Equal spids:[1365])]
                  spids: [1363]
                )
                (C {(_get_first_arg)})
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: (BoolUnary op_id:BoolUnary_z child:{($ VSub_Name "$arg")})
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (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: [
                                (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\" )">)} {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                        )
                                                      ]
                                                    )
                                                  left_token: <Left_CommandSub "$(">
                                                  spids: [1407 1423]
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [1404]
                                    )
                                  ]
                                  spids: [1404]
                                )
                              ]
                              spids: [-1 1401]
                            )
                          ]
                          else_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 <"show connect listen watch bind\n"> 
                                                          <"                release">
                                                        )
                                                      } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub "$(">
                                              spids: [1434 1451]
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [1431]
                                )
                              ]
                              spids: [1431]
                            )
                          ]
                          spids: [1428 1456]
                        )
                      ]
                      spids: [-1 1382]
                    )
                  ]
                  else_action: [
                    (Assignment
                      keyword: Assign_Local
                      pairs: [(assign_pair lhs:(LhsName name:args) op:Equal spids:[1464])]
                      spids: [1462]
                    )
                    (C {(_count_args)})
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (BoolBinary
                                      op_id: BoolBinary_eq
                                      left: {($ VSub_Name "$args")}
                                      right: {(2)}
                                    )
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [(C {(_bluetooth_devices)})]
                          spids: [-1 1483]
                        )
                      ]
                      else_action: [
                        (Case
                          to_match: {($ VSub_Name "$arg")}
                          arms: [
                            (case_arm
                              pat_list: [{(connect)} {(bind)}]
                              action: [
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (Sentence
                                          child: 
                                            (DBracket
                                              expr: 
                                                (BoolBinary
                                                  op_id: BoolBinary_eq
                                                  left: {($ VSub_Name "$args")}
                                                  right: {(3)}
                                                )
                                            )
                                          terminator: <Op_Semi ";">
                                        )
                                      ]
                                      action: [(C {(_bluetooth_adresses)})]
                                      spids: [-1 1518]
                                    )
                                  ]
                                  spids: [-1 1524]
                                )
                              ]
                              spids: [1499 1502 1527 -1]
                            )
                          ]
                          spids: [1492 1496 1530]
                        )
                      ]
                      spids: [1489 1533]
                    )
                  ]
                  spids: [1459 1536]
                )
              ]
              spids: [1295]
            )
          spids: [1291 1294]
        )
        (C {(complete)} {(-F)} {(_rfcomm)} {(rfcomm)})
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (FuncDef
          name: _ciptool
          body: 
            (BraceGroup
              children: [
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair lhs:(LhsName name:cur) op:Equal spids:[1560])
                    (assign_pair lhs:(LhsName name:prev) op:Equal spids:[1562])
                    (assign_pair lhs:(LhsName name:words) op:Equal spids:[1564])
                    (assign_pair lhs:(LhsName name:cword) op:Equal spids:[1566])
                  ]
                  spids: [1558]
                )
                (AndOr
                  children: [(C {(_init_completion)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DPipe
                )
                (Case
                  to_match: {($ VSub_Name "$prev")}
                  arms: [
                    (case_arm
                      pat_list: [{(-i)}]
                      action: [
                        (C {(_bluetooth_devices)})
                        (C {(_bluetooth_adresses)})
                        (ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [1584 1585 1599 -1]
                    )
                  ]
                  spids: [1577 1581 1602]
                )
                (Assignment
                  keyword: Assign_Local
                  pairs: [(assign_pair lhs:(LhsName name:arg) op:Equal spids:[1608])]
                  spids: [1606]
                )
                (C {(_get_first_arg)})
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: (BoolUnary op_id:BoolUnary_z child:{($ VSub_Name "$arg")})
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (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: [
                                (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\" )">)} {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                        )
                                                      ]
                                                    )
                                                  left_token: <Left_CommandSub "$(">
                                                  spids: [1650 1666]
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [1647]
                                    )
                                  ]
                                  spids: [1647]
                                )
                              ]
                              spids: [-1 1644]
                            )
                          ]
                          else_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 <"show search connect release loopback">)} {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub "$(">
                                              spids: [1677 1695]
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [1674]
                                )
                              ]
                              spids: [1674]
                            )
                          ]
                          spids: [1671 1700]
                        )
                      ]
                      spids: [-1 1625]
                    )
                  ]
                  else_action: [
                    (Assignment
                      keyword: Assign_Local
                      pairs: [(assign_pair lhs:(LhsName name:args) op:Equal spids:[1708])]
                      spids: [1706]
                    )
                    (Case
                      to_match: {($ VSub_Name "$arg")}
                      arms: [
                        (case_arm
                          pat_list: [{(connect)} {(release)} {(loopback)}]
                          action: [
                            (C {(_count_args)})
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (DBracket
                                          expr: 
                                            (BoolBinary
                                              op_id: BoolBinary_eq
                                              left: {($ VSub_Name "$args")}
                                              right: {(2)}
                                            )
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [(C {(_bluetooth_adresses)})]
                                  spids: [-1 1742]
                                )
                              ]
                              spids: [-1 1748]
                            )
                          ]
                          spids: [1718 1723 1751 -1]
                        )
                      ]
                      spids: [1711 1715 1754]
                    )
                  ]
                  spids: [1703 1757]
                )
              ]
              spids: [1555]
            )
          spids: [1551 1554]
        )
        (C {(complete)} {(-F)} {(_ciptool)} {(ciptool)})
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (FuncDef
          name: _dfutool
          body: 
            (BraceGroup
              children: [
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair lhs:(LhsName name:cur) op:Equal spids:[1781])
                    (assign_pair lhs:(LhsName name:prev) op:Equal spids:[1783])
                    (assign_pair lhs:(LhsName name:words) op:Equal spids:[1785])
                    (assign_pair lhs:(LhsName name:cword) op:Equal spids:[1787])
                  ]
                  spids: [1779]
                )
                (AndOr
                  children: [(C {(_init_completion)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DPipe
                )
                (Case
                  to_match: {($ VSub_Name "$prev")}
                  arms: [
                    (case_arm
                      pat_list: [{(-d)} {(--device)}]
                      action: [
                        (C {(_bluetooth_devices)})
                        (ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      spids: [1805 1808 1819 -1]
                    )
                  ]
                  spids: [1798 1802 1822]
                )
                (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: [
                        (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\" )">)} 
                                                  {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [1848 1864]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1845]
                            )
                          ]
                          spids: [1845]
                        )
                      ]
                      spids: [-1 1842]
                    )
                  ]
                  else_action: [
                    (Assignment
                      keyword: Assign_Local
                      pairs: [(assign_pair lhs:(LhsName name:args) op:Equal spids:[1874])]
                      spids: [1872]
                    )
                    (C {(_count_args)})
                    (Case
                      to_match: {($ VSub_Name "$args")}
                      arms: [
                        (case_arm
                          pat_list: [{(1)}]
                          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 <"verify modify upgrade archive">)} {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub "$(">
                                              spids: [1894 1912]
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [1891]
                                )
                              ]
                              spids: [1891]
                            )
                          ]
                          spids: [1887 1888 1917 -1]
                        )
                        (case_arm
                          pat_list: [{(2)}]
                          action: [(C {(_filedir)})]
                          spids: [1920 1921 1927 -1]
                        )
                      ]
                      spids: [1880 1884 1930]
                    )
                  ]
                  spids: [1869 1933]
                )
              ]
              spids: [1776]
            )
          spids: [1772 1775]
        )
        (C {(complete)} {(-F)} {(_dfutool)} {(dfutool)})
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (FuncDef
          name: _hciconfig
          body: 
            (BraceGroup
              children: [
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair lhs:(LhsName name:cur) op:Equal spids:[1957])
                    (assign_pair lhs:(LhsName name:prev) op:Equal spids:[1959])
                    (assign_pair lhs:(LhsName name:words) op:Equal spids:[1961])
                    (assign_pair lhs:(LhsName name:cword) op:Equal spids:[1963])
                  ]
                  spids: [1955]
                )
                (AndOr
                  children: [(C {(_init_completion)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DPipe
                )
                (Assignment
                  keyword: Assign_Local
                  pairs: [(assign_pair lhs:(LhsName name:arg) op:Equal spids:[1976])]
                  spids: [1974]
                )
                (C {(_get_first_arg)})
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: (BoolUnary op_id:BoolUnary_z child:{($ VSub_Name "$arg")})
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (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: [
                                (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 <"--help --all">)} 
                                                          {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                        )
                                                      ]
                                                    )
                                                  left_token: <Left_CommandSub "$(">
                                                  spids: [2018 2034]
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [2015]
                                    )
                                  ]
                                  spids: [2015]
                                )
                              ]
                              spids: [-1 2012]
                            )
                          ]
                          else_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 
                                                          <
"up down reset rstat auth noauth encrypt\n"
                                                          > <"                noencrypt secmgr nosecmgr piscan noscan iscan pscan ptype name\n"> 
                                                          <
"                class voice iac inqmode inqdata inqtype inqparams pageparms\n"
                                                          > <"                pageto afhmode aclmtu scomtu putkey delkey commands features\n"> 
                                                          <"                version revision lm">
                                                        )
                                                      } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub "$(">
                                              spids: [2045 2065]
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [2042]
                                )
                              ]
                              spids: [2042]
                            )
                          ]
                          spids: [2039 2070]
                        )
                      ]
                      spids: [-1 1993]
                    )
                  ]
                  else_action: [
                    (Assignment
                      keyword: Assign_Local
                      pairs: [(assign_pair lhs:(LhsName name:args) op:Equal spids:[2078])]
                      spids: [2076]
                    )
                    (Case
                      to_match: {($ VSub_Name "$arg")}
                      arms: [
                        (case_arm
                          pat_list: [{(putkey)} {(delkey)}]
                          action: [
                            (C {(_count_args)})
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (DBracket
                                          expr: 
                                            (BoolBinary
                                              op_id: BoolBinary_eq
                                              left: {($ VSub_Name "$args")}
                                              right: {(2)}
                                            )
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [(C {(_bluetooth_adresses)})]
                                  spids: [-1 2110]
                                )
                              ]
                              spids: [-1 2116]
                            )
                          ]
                          spids: [2088 2091 2119 -1]
                        )
                        (case_arm
                          pat_list: [{(lm)}]
                          action: [
                            (C {(_count_args)})
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (DBracket
                                          expr: 
                                            (BoolBinary
                                              op_id: BoolBinary_eq
                                              left: {($ VSub_Name "$args")}
                                              right: {(2)}
                                            )
                                        )
                                      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 <"MASTER SLAVE NONE ACCEPT">)} {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                            )
                                                          ]
                                                        )
                                                      left_token: <Left_CommandSub "$(">
                                                      spids: [2148 2166]
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [2145]
                                        )
                                      ]
                                      spids: [2145]
                                    )
                                  ]
                                  spids: [-1 2142]
                                )
                              ]
                              spids: [-1 2171]
                            )
                          ]
                          spids: [2122 2123 2174 -1]
                        )
                        (case_arm
                          pat_list: [{(ptype)}]
                          action: [
                            (C {(_count_args)})
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (DBracket
                                          expr: 
                                            (BoolBinary
                                              op_id: BoolBinary_eq
                                              left: {($ VSub_Name "$args")}
                                              right: {(2)}
                                            )
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [(C {(_bluetooth_packet_types)})]
                                  spids: [-1 2197]
                                )
                              ]
                              spids: [-1 2203]
                            )
                          ]
                          spids: [2177 2178 2206 -1]
                        )
                      ]
                      spids: [2081 2085 2209]
                    )
                  ]
                  spids: [2073 2212]
                )
              ]
              spids: [1952]
            )
          spids: [1948 1951]
        )
        (C {(complete)} {(-F)} {(_hciconfig)} {(hciconfig)})
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (FuncDef
          name: _hciattach
          body: 
            (BraceGroup
              children: [
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair lhs:(LhsName name:cur) op:Equal spids:[2236])
                    (assign_pair lhs:(LhsName name:prev) op:Equal spids:[2238])
                    (assign_pair lhs:(LhsName name:words) op:Equal spids:[2240])
                    (assign_pair lhs:(LhsName name:cword) op:Equal spids:[2242])
                  ]
                  spids: [2234]
                )
                (AndOr
                  children: [(C {(_init_completion)}) (ControlFlow token:<ControlFlow_Return return>)]
                  op_id: Op_DPipe
                )
                (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: [
                        (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 <"-n -p -t -b -s -l">)} {(--)} 
                                                  {(DQ ($ VSub_Name "$cur"))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [2275 2291]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [2272]
                            )
                          ]
                          spids: [2272]
                        )
                      ]
                      spids: [-1 2269]
                    )
                  ]
                  else_action: [
                    (Assignment
                      keyword: Assign_Local
                      pairs: [(assign_pair lhs:(LhsName name:args) op:Equal spids:[2301])]
                      spids: [2299]
                    )
                    (C {(_count_args)})
                    (Case
                      to_match: {($ VSub_Name "$args")}
                      arms: [
                        (case_arm
                          pat_list: [{(1)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:COMPREPLY)
                                  op: Equal
                                  rhs: 
                                    {
                                      (ArrayLiteralPart
                                        words: [
                                          {
                                            (CommandSubPart
                                              command_list: 
                                                (CommandList
                                                  children: [
                                                    (C {(printf)} {(SQ <"%s\\n">)} 
                                                      {(/dev/tty) (Lit_Other "*")}
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub "$(">
                                              spids: [2321 2332]
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [2318]
                                )
                              ]
                              spids: [2318]
                            )
                            (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 <"${COMPREPLY[@]}\n"> 
                                                          <
"                    ${COMPREPLY[@]#/dev/}"
                                                          >
                                                        )
                                                      } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub "$(">
                                              spids: [2340 2357]
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [2337]
                                )
                              ]
                              spids: [2337]
                            )
                          ]
                          spids: [2314 2315 2362 -1]
                        )
                        (case_arm
                          pat_list: [{(2)}]
                          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 <"any ericsson digi xircom csr bboxes\n"> 
                                                          <
"                    swave bcsp 0x0105 0x080a 0x0160 0x0002"
                                                          >
                                                        )
                                                      } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub "$(">
                                              spids: [2372 2389]
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [2369]
                                )
                              ]
                              spids: [2369]
                            )
                          ]
                          spids: [2365 2366 2394 -1]
                        )
                        (case_arm
                          pat_list: [{(3)}]
                          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 
                                                          <
"9600 19200 38400 57600 115200 230400\n"
                                                          > <"                    460800 921600">
                                                        )
                                                      } {(--)} {(DQ ($ VSub_Name "$cur"))}
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub "$(">
                                              spids: [2404 2421]
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [2401]
                                )
                              ]
                              spids: [2401]
                            )
                          ]
                          spids: [2397 2398 2426 -1]
                        )
                        (case_arm
                          pat_list: [{(4)}]
                          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 <"flow noflow">)} {(--)} 
                                                      {(DQ ($ VSub_Name "$cur"))}
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub "$(">
                                              spids: [2436 2452]
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [2433]
                                )
                              ]
                              spids: [2433]
                            )
                          ]
                          spids: [2429 2430 2457 -1]
                        )
                        (case_arm
                          pat_list: [{(5)}]
                          action: [(C {(_bluetooth_adresses)})]
                          spids: [2460 2461 2467 -1]
                        )
                      ]
                      spids: [2307 2311 2470]
                    )
                  ]
                  spids: [2296 2473]
                )
              ]
              spids: [2231]
            )
          spids: [2227 2230]
        )
        (C {(complete)} {(-F)} {(_hciattach)} {(hciattach)})
      ]
      op_id: Op_DAmp
    )
  ]
)