(command.CommandList
  children: [
    (command.ShFunction
      name: _bluetooth_adresses
      body: 
        (command.BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_n
                              child: 
                                {
                                  (braced_var_sub
                                    token: <Id.VSub_Name COMP_BLUETOOTH_SCAN>
                                    suffix_op: (suffix_op.Unary op_id:Id.VTest_ColonHyphen arg_word:{})
                                  )
                                }
                            )
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:COMPREPLY)
                          op: assign_op.PlusEqual
                          rhs: 
                            {
                              (sh_array_literal
                                left: <Id.Op_LParen _>
                                words: [
                                  {
                                    (command_sub
                                      left_token: <Id.Left_DollarParen '$('>
                                      command_list: 
                                        (command.CommandList
                                          children: [
                                            (C {<compgen>} {<-W>} 
                                              {
                                                (DQ 
                                                  (command_sub
                                                    left_token: <Id.Left_DollarParen '$('>
                                                    command_list: 
                                                      (command.CommandList
                                                        children: [
                                                          (command.Pipeline
                                                            children: [
                                                              (C {<hcitool>} {<scan>})
                                                              (C {<awk>} {(SQ <'/^\\t/{print $1}'>)})
                                                            ]
                                                            negated: F
                                                          )
                                                        ]
                                                      )
                                                  )
                                                )
                                              } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                            )
                                          ]
                                        )
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [28]
                        )
                      ]
                    )
                  ]
                  spids: [11 25]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: _bluetooth_devices
      body: 
        (command.BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                  op: assign_op.PlusEqual
                  rhs: 
                    {
                      (sh_array_literal
                        left: <Id.Op_LParen _>
                        words: [
                          {
                            (command_sub
                              left_token: <Id.Left_DollarParen '$('>
                              command_list: 
                                (command.CommandList
                                  children: [
                                    (C {<compgen>} {<-W>} 
                                      {
                                        (DQ 
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (command.Pipeline
                                                    children: [
                                                      (C {<hcitool>} {<dev>})
                                                      (C {<awk>} {(SQ <'/^\\t/{print $1}'>)})
                                                    ]
                                                    negated: F
                                                  )
                                                ]
                                              )
                                          )
                                        )
                                      } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                    )
                                  ]
                                )
                            )
                          }
                        ]
                      )
                    }
                  spids: [80]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: _bluetooth_services
      body: 
        (command.BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (sh_array_literal
                        left: <Id.Op_LParen _>
                        words: [
                          {
                            (command_sub
                              left_token: <Id.Left_DollarParen '$('>
                              command_list: 
                                (command.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 ($ Id.VSub_DollarName '$cur'))}
                                    )
                                  ]
                                )
                            )
                          }
                        ]
                      )
                    }
                  spids: [129]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: _bluetooth_packet_types
      body: 
        (command.BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (sh_array_literal
                        left: <Id.Op_LParen _>
                        words: [
                          {
                            (command_sub
                              left_token: <Id.Left_DollarParen '$('>
                              command_list: 
                                (command.CommandList
                                  children: [
                                    (C {<compgen>} {<-W>} {(SQ <'DM1 DM3 DM5 DH1 DH3 DH5 HV1 HV2 HV3'>)} 
                                      {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                    )
                                  ]
                                )
                            )
                          }
                        ]
                      )
                    }
                  spids: [165]
                )
              ]
            )
          ]
        )
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (command.ShFunction
          name: _hcitool
          body: 
            (command.BraceGroup
              children: [
                (C {<local>} {<cur>} {<prev>} {<words>} {<cword>} {<split>})
                (command.AndOr
                  ops: [Id.Op_DPipe]
                  children: [
                    (C {<_init_completion>} {<-s>})
                    (command.ControlFlow token:<Id.ControlFlow_Return return>)
                  ]
                )
                (command.Case
                  to_match: {($ Id.VSub_DollarName '$prev')}
                  arms: [
                    (case_arm
                      pat_list: [{<-i>}]
                      action: [
                        (C {<_bluetooth_devices>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [230 231 242 -1]
                    )
                    (case_arm
                      pat_list: [{<--role>}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {<compgen>} {<-W>} {(SQ <'m s'>)} {<-->} 
                                                  {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [249]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [245 246 278 -1]
                    )
                    (case_arm
                      pat_list: [{<--pkt-type>}]
                      action: [
                        (C {<_bluetooth_packet_types>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [281 282 293 -1]
                    )
                  ]
                )
                (command.AndOr
                  ops: [Id.Op_DAmp]
                  children: [
                    (C {($ Id.VSub_DollarName '$split')})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                )
                (C {<local>} {<arg>})
                (C {<_get_first_arg>})
                (command.If
                  arms: [
                    (if_arm
                      cond: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_z
                                  child: {($ Id.VSub_DollarName '$arg')}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                      action: [
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                          right: {<-> <Id.Lit_Other '*'>}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (sh_array_literal
                                            left: <Id.Op_LParen _>
                                            words: [
                                              {
                                                (command_sub
                                                  left_token: <Id.Left_DollarParen '$('>
                                                  command_list: 
                                                    (command.CommandList
                                                      children: [
                                                        (C {<compgen>} {<-W>} 
                                                          {(SQ <'$( _parse_help "$1" )'>)} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                        )
                                                      ]
                                                    )
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [351]
                                    )
                                  ]
                                )
                              ]
                              spids: [332 348]
                            )
                          ]
                          else_action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              command_list: 
                                                (command.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 ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [378]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                      spids: [318 329]
                    )
                  ]
                  else_action: [
                    (C {<local>} {<args>})
                    (command.Case
                      to_match: {($ Id.VSub_DollarName '$arg')}
                      arms: [
                        (case_arm
                          pat_list: [
                            {<name>}
                            {<info>}
                            {<dc>}
                            {<rssi>}
                            {<lq>}
                            {<afh>}
                            {<auth>}
                            {<key>}
                            {<clkoff>}
                            {<lst>}
                          ]
                          action: [
                            (C {<_count_args>})
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_eq
                                              left: {($ Id.VSub_DollarName '$args')}
                                              right: {<2>}
                                            )
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                  action: [(C {<_bluetooth_adresses>})]
                                  spids: [447 460]
                                )
                              ]
                            )
                          ]
                          spids: [422 441 469 -1]
                        )
                        (case_arm
                          pat_list: [{<cc>}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                              right: {<-> <Id.Lit_Other '*'>}
                                            )
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (sh_array_literal
                                                left: <Id.Op_LParen _>
                                                words: [
                                                  {
                                                    (command_sub
                                                      left_token: <Id.Left_DollarParen '$('>
                                                      command_list: 
                                                        (command.CommandList
                                                          children: [
                                                            (C {<compgen>} {<-W>} 
                                                              {(SQ <'--role --pkt-type'>)} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                            )
                                                          ]
                                                        )
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [495]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [476 492]
                                )
                              ]
                              else_action: [
                                (C {<_count_args>})
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (command.Sentence
                                          child: 
                                            (command.DBracket
                                              expr: 
                                                (bool_expr.Binary
                                                  op_id: Id.BoolBinary_eq
                                                  left: {($ Id.VSub_DollarName '$args')}
                                                  right: {<2>}
                                                )
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                      action: [(C {<_bluetooth_adresses>})]
                                      spids: [525 538]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                          spids: [472 473 550 -1]
                        )
                        (case_arm
                          pat_list: [{<sr>}]
                          action: [
                            (C {<_count_args>})
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_eq
                                              left: {($ Id.VSub_DollarName '$args')}
                                              right: {<2>}
                                            )
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                  action: [(C {<_bluetooth_adresses>})]
                                  spids: [560 573]
                                )
                              ]
                              else_action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (sh_array_literal
                                            left: <Id.Op_LParen _>
                                            words: [
                                              {
                                                (command_sub
                                                  left_token: <Id.Left_DollarParen '$('>
                                                  command_list: 
                                                    (command.CommandList
                                                      children: [
                                                        (C {<compgen>} {<-W>} {(SQ <'master slave'>)} 
                                                          {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                        )
                                                      ]
                                                    )
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [582]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                          spids: [553 554 609 -1]
                        )
                        (case_arm
                          pat_list: [{<cpt>}]
                          action: [
                            (C {<_count_args>})
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_eq
                                              left: {($ Id.VSub_DollarName '$args')}
                                              right: {<2>}
                                            )
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                  action: [(C {<_bluetooth_adresses>})]
                                  spids: [619 632]
                                )
                              ]
                              else_action: [(C {<_bluetooth_packet_types>})]
                            )
                          ]
                          spids: [612 613 647 -1]
                        )
                        (case_arm
                          pat_list: [{<tpl>} {<enc>} {<clock>}]
                          action: [
                            (C {<_count_args>})
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_eq
                                              left: {($ Id.VSub_DollarName '$args')}
                                              right: {<2>}
                                            )
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                  action: [(C {<_bluetooth_adresses>})]
                                  spids: [661 674]
                                )
                              ]
                              else_action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (sh_array_literal
                                            left: <Id.Op_LParen _>
                                            words: [
                                              {
                                                (command_sub
                                                  left_token: <Id.Left_DollarParen '$('>
                                                  command_list: 
                                                    (command.CommandList
                                                      children: [
                                                        (C {<compgen>} {<-W>} {(SQ <'0 1'>)} {<-->} 
                                                          {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                        )
                                                      ]
                                                    )
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [683]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                          spids: [650 655 710 -1]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
        )
        (C {<complete>} {<-F>} {<_hcitool>} {<hcitool>})
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (command.ShFunction
          name: _sdptool
          body: 
            (command.BraceGroup
              children: [
                (C {<local>} {<cur>} {<prev>} {<words>} {<cword>} {<split>})
                (command.AndOr
                  ops: [Id.Op_DPipe]
                  children: [
                    (C {<_init_completion>} {<-s>})
                    (command.ControlFlow token:<Id.ControlFlow_Return return>)
                  ]
                )
                (command.Case
                  to_match: {($ Id.VSub_DollarName '$prev')}
                  arms: [
                    (case_arm
                      pat_list: [{<--bdaddr>}]
                      action: [
                        (C {<_bluetooth_adresses>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [768 769 780 -1]
                    )
                  ]
                )
                (command.AndOr
                  ops: [Id.Op_DAmp]
                  children: [
                    (C {($ Id.VSub_DollarName '$split')})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                )
                (C {<local>} {<arg>})
                (C {<_get_first_arg>})
                (command.If
                  arms: [
                    (if_arm
                      cond: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_z
                                  child: {($ Id.VSub_DollarName '$arg')}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                      action: [
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                          right: {<-> <Id.Lit_Other '*'>}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (sh_array_literal
                                            left: <Id.Op_LParen _>
                                            words: [
                                              {
                                                (command_sub
                                                  left_token: <Id.Left_DollarParen '$('>
                                                  command_list: 
                                                    (command.CommandList
                                                      children: [
                                                        (C {<compgen>} {<-W>} 
                                                          {(SQ <'$( _parse_help "$1" )'>)} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                        )
                                                      ]
                                                    )
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [838]
                                    )
                                  ]
                                )
                              ]
                              spids: [819 835]
                            )
                          ]
                          else_action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {<compgen>} {<-W>} 
                                                      {
                                                        (SQ <'search browse records add del get\n'> 
                                                          <'                setattr setseq'>
                                                        )
                                                      } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [865]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                      spids: [805 816]
                    )
                  ]
                  else_action: [
                    (command.Case
                      to_match: {($ Id.VSub_DollarName '$arg')}
                      arms: [
                        (case_arm
                          pat_list: [{<search>}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                              right: {<-> <Id.Lit_Other '*'>}
                                            )
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (sh_array_literal
                                                left: <Id.Op_LParen _>
                                                words: [
                                                  {
                                                    (command_sub
                                                      left_token: <Id.Left_DollarParen '$('>
                                                      command_list: 
                                                        (command.CommandList
                                                          children: [
                                                            (C {<compgen>} {<-W>} 
                                                              {(SQ <'--bdaddr --tree --raw --xml'>)} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                            )
                                                          ]
                                                        )
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [926]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [907 923]
                                )
                              ]
                              else_action: [(C {<_bluetooth_services>})]
                            )
                          ]
                          spids: [903 904 961 -1]
                        )
                        (case_arm
                          pat_list: [{<browse>} {<records>}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                              right: {<-> <Id.Lit_Other '*'>}
                                            )
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (sh_array_literal
                                                left: <Id.Op_LParen _>
                                                words: [
                                                  {
                                                    (command_sub
                                                      left_token: <Id.Left_DollarParen '$('>
                                                      command_list: 
                                                        (command.CommandList
                                                          children: [
                                                            (C {<compgen>} {<-W>} 
                                                              {(SQ <'--tree --raw --xml'>)} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                            )
                                                          ]
                                                        )
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [989]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [970 986]
                                )
                              ]
                              else_action: [(C {<_bluetooth_adresses>})]
                            )
                          ]
                          spids: [964 967 1022 -1]
                        )
                        (case_arm
                          pat_list: [{<add>}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                              right: {<-> <Id.Lit_Other '*'>}
                                            )
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (sh_array_literal
                                                left: <Id.Op_LParen _>
                                                words: [
                                                  {
                                                    (command_sub
                                                      left_token: <Id.Left_DollarParen '$('>
                                                      command_list: 
                                                        (command.CommandList
                                                          children: [
                                                            (C {<compgen>} {<-W>} 
                                                              {(SQ <'--handle --channel'>)} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                            )
                                                          ]
                                                        )
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [1048]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [1029 1045]
                                )
                              ]
                              else_action: [(C {<_bluetooth_services>})]
                            )
                          ]
                          spids: [1025 1026 1081 -1]
                        )
                        (case_arm
                          pat_list: [{<get>}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                              right: {<-> <Id.Lit_Other '*'>}
                                            )
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (sh_array_literal
                                                left: <Id.Op_LParen _>
                                                words: [
                                                  {
                                                    (command_sub
                                                      left_token: <Id.Left_DollarParen '$('>
                                                      command_list: 
                                                        (command.CommandList
                                                          children: [
                                                            (C {<compgen>} {<-W>} 
                                                              {(SQ <'--bdaddr --tree --raw --xml'>)} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                            )
                                                          ]
                                                        )
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [1107]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [1088 1104]
                                )
                              ]
                            )
                          ]
                          spids: [1084 1085 1136 -1]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
        )
        (C {<complete>} {<-F>} {<_sdptool>} {<sdptool>})
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (command.ShFunction
          name: _l2ping
          body: 
            (command.BraceGroup
              children: [
                (C {<local>} {<cur>} {<prev>} {<words>} {<cword>})
                (command.AndOr
                  ops: [Id.Op_DPipe]
                  children: [
                    (C {<_init_completion>})
                    (command.ControlFlow token:<Id.ControlFlow_Return return>)
                  ]
                )
                (command.Case
                  to_match: {($ Id.VSub_DollarName '$prev')}
                  arms: [
                    (case_arm
                      pat_list: [{<-i>}]
                      action: [
                        (C {<_bluetooth_devices>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1190 1191 1202 -1]
                    )
                    (case_arm
                      pat_list: [{<-s>} {<-c>} {<-t>} {<-d>}]
                      action: [
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1205 1212 1220 -1]
                    )
                  ]
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                  right: {<-> <Id.Lit_Other '*'>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {<compgen>} {<-W>} {(SQ <'$( _parse_usage "$1" )'>)} 
                                                  {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1246]
                            )
                          ]
                        )
                      ]
                      spids: [1227 1243]
                    )
                  ]
                  else_action: [(C {<_bluetooth_adresses>})]
                )
              ]
            )
        )
        (C {<complete>} {<-F>} {<_l2ping>} {<l2ping>})
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (command.ShFunction
          name: _rfcomm
          body: 
            (command.BraceGroup
              children: [
                (C {<local>} {<cur>} {<prev>} {<words>} {<cword>})
                (command.AndOr
                  ops: [Id.Op_DPipe]
                  children: [
                    (C {<_init_completion>})
                    (command.ControlFlow token:<Id.ControlFlow_Return return>)
                  ]
                )
                (command.Case
                  to_match: {($ Id.VSub_DollarName '$prev')}
                  arms: [
                    (case_arm
                      pat_list: [{<-f>} {<--config>}]
                      action: [
                        (C {<_filedir>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1324 1327 1338 -1]
                    )
                    (case_arm
                      pat_list: [{<-i>}]
                      action: [
                        (C {<_bluetooth_devices>})
                        (C {<_bluetooth_adresses>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1341 1342 1356 -1]
                    )
                  ]
                )
                (C {<local>} {<arg>})
                (C {<_get_first_arg>})
                (command.If
                  arms: [
                    (if_arm
                      cond: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_z
                                  child: {($ Id.VSub_DollarName '$arg')}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                      action: [
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                          right: {<-> <Id.Lit_Other '*'>}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (sh_array_literal
                                            left: <Id.Op_LParen _>
                                            words: [
                                              {
                                                (command_sub
                                                  left_token: <Id.Left_DollarParen '$('>
                                                  command_list: 
                                                    (command.CommandList
                                                      children: [
                                                        (C {<compgen>} {<-W>} 
                                                          {(SQ <'$( _parse_help "$1" )'>)} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                        )
                                                      ]
                                                    )
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [1404]
                                    )
                                  ]
                                )
                              ]
                              spids: [1385 1401]
                            )
                          ]
                          else_action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {<compgen>} {<-W>} 
                                                      {
                                                        (SQ <'show connect listen watch bind\n'> 
                                                          <'                release'>
                                                        )
                                                      } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [1431]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                      spids: [1371 1382]
                    )
                  ]
                  else_action: [
                    (C {<local>} {<args>})
                    (C {<_count_args>})
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_eq
                                      left: {($ Id.VSub_DollarName '$args')}
                                      right: {<2>}
                                    )
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                          action: [(C {<_bluetooth_devices>})]
                          spids: [1470 1483]
                        )
                      ]
                      else_action: [
                        (command.Case
                          to_match: {($ Id.VSub_DollarName '$arg')}
                          arms: [
                            (case_arm
                              pat_list: [{<connect>} {<bind>}]
                              action: [
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (command.Sentence
                                          child: 
                                            (command.DBracket
                                              expr: 
                                                (bool_expr.Binary
                                                  op_id: Id.BoolBinary_eq
                                                  left: {($ Id.VSub_DollarName '$args')}
                                                  right: {<3>}
                                                )
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                      action: [(C {<_bluetooth_adresses>})]
                                      spids: [1505 1518]
                                    )
                                  ]
                                )
                              ]
                              spids: [1499 1502 1527 -1]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
        )
        (C {<complete>} {<-F>} {<_rfcomm>} {<rfcomm>})
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (command.ShFunction
          name: _ciptool
          body: 
            (command.BraceGroup
              children: [
                (C {<local>} {<cur>} {<prev>} {<words>} {<cword>})
                (command.AndOr
                  ops: [Id.Op_DPipe]
                  children: [
                    (C {<_init_completion>})
                    (command.ControlFlow token:<Id.ControlFlow_Return return>)
                  ]
                )
                (command.Case
                  to_match: {($ Id.VSub_DollarName '$prev')}
                  arms: [
                    (case_arm
                      pat_list: [{<-i>}]
                      action: [
                        (C {<_bluetooth_devices>})
                        (C {<_bluetooth_adresses>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1584 1585 1599 -1]
                    )
                  ]
                )
                (C {<local>} {<arg>})
                (C {<_get_first_arg>})
                (command.If
                  arms: [
                    (if_arm
                      cond: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_z
                                  child: {($ Id.VSub_DollarName '$arg')}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                      action: [
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                          right: {<-> <Id.Lit_Other '*'>}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (sh_array_literal
                                            left: <Id.Op_LParen _>
                                            words: [
                                              {
                                                (command_sub
                                                  left_token: <Id.Left_DollarParen '$('>
                                                  command_list: 
                                                    (command.CommandList
                                                      children: [
                                                        (C {<compgen>} {<-W>} 
                                                          {(SQ <'$( _parse_help "$1" )'>)} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                        )
                                                      ]
                                                    )
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [1647]
                                    )
                                  ]
                                )
                              ]
                              spids: [1628 1644]
                            )
                          ]
                          else_action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {<compgen>} {<-W>} 
                                                      {(SQ <'show search connect release loopback'>)} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [1674]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                      spids: [1614 1625]
                    )
                  ]
                  else_action: [
                    (C {<local>} {<args>})
                    (command.Case
                      to_match: {($ Id.VSub_DollarName '$arg')}
                      arms: [
                        (case_arm
                          pat_list: [{<connect>} {<release>} {<loopback>}]
                          action: [
                            (C {<_count_args>})
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_eq
                                              left: {($ Id.VSub_DollarName '$args')}
                                              right: {<2>}
                                            )
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                  action: [(C {<_bluetooth_adresses>})]
                                  spids: [1729 1742]
                                )
                              ]
                            )
                          ]
                          spids: [1718 1723 1751 -1]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
        )
        (C {<complete>} {<-F>} {<_ciptool>} {<ciptool>})
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (command.ShFunction
          name: _dfutool
          body: 
            (command.BraceGroup
              children: [
                (C {<local>} {<cur>} {<prev>} {<words>} {<cword>})
                (command.AndOr
                  ops: [Id.Op_DPipe]
                  children: [
                    (C {<_init_completion>})
                    (command.ControlFlow token:<Id.ControlFlow_Return return>)
                  ]
                )
                (command.Case
                  to_match: {($ Id.VSub_DollarName '$prev')}
                  arms: [
                    (case_arm
                      pat_list: [{<-d>} {<--device>}]
                      action: [
                        (C {<_bluetooth_devices>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [1805 1808 1819 -1]
                    )
                  ]
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                  right: {<-> <Id.Lit_Other '*'>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {<compgen>} {<-W>} {(SQ <'$( _parse_help "$1" )'>)} 
                                                  {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [1845]
                            )
                          ]
                        )
                      ]
                      spids: [1826 1842]
                    )
                  ]
                  else_action: [
                    (C {<local>} {<args>})
                    (C {<_count_args>})
                    (command.Case
                      to_match: {($ Id.VSub_DollarName '$args')}
                      arms: [
                        (case_arm
                          pat_list: [{<1>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {<compgen>} {<-W>} 
                                                      {(SQ <'verify modify upgrade archive'>)} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [1891]
                                )
                              ]
                            )
                          ]
                          spids: [1887 1888 1917 -1]
                        )
                        (case_arm
                          pat_list: [{<2>}]
                          action: [(C {<_filedir>})]
                          spids: [1920 1921 1927 -1]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
        )
        (C {<complete>} {<-F>} {<_dfutool>} {<dfutool>})
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (command.ShFunction
          name: _hciconfig
          body: 
            (command.BraceGroup
              children: [
                (C {<local>} {<cur>} {<prev>} {<words>} {<cword>})
                (command.AndOr
                  ops: [Id.Op_DPipe]
                  children: [
                    (C {<_init_completion>})
                    (command.ControlFlow token:<Id.ControlFlow_Return return>)
                  ]
                )
                (C {<local>} {<arg>})
                (C {<_get_first_arg>})
                (command.If
                  arms: [
                    (if_arm
                      cond: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_z
                                  child: {($ Id.VSub_DollarName '$arg')}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                      action: [
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                          right: {<-> <Id.Lit_Other '*'>}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (sh_array_literal
                                            left: <Id.Op_LParen _>
                                            words: [
                                              {
                                                (command_sub
                                                  left_token: <Id.Left_DollarParen '$('>
                                                  command_list: 
                                                    (command.CommandList
                                                      children: [
                                                        (C {<compgen>} {<-W>} {(SQ <'--help --all'>)} 
                                                          {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                        )
                                                      ]
                                                    )
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [2015]
                                    )
                                  ]
                                )
                              ]
                              spids: [1996 2012]
                            )
                          ]
                          else_action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              command_list: 
                                                (command.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 ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [2042]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                      spids: [1982 1993]
                    )
                  ]
                  else_action: [
                    (C {<local>} {<args>})
                    (command.Case
                      to_match: {($ Id.VSub_DollarName '$arg')}
                      arms: [
                        (case_arm
                          pat_list: [{<putkey>} {<delkey>}]
                          action: [
                            (C {<_count_args>})
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_eq
                                              left: {($ Id.VSub_DollarName '$args')}
                                              right: {<2>}
                                            )
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                  action: [(C {<_bluetooth_adresses>})]
                                  spids: [2097 2110]
                                )
                              ]
                            )
                          ]
                          spids: [2088 2091 2119 -1]
                        )
                        (case_arm
                          pat_list: [{<lm>}]
                          action: [
                            (C {<_count_args>})
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_eq
                                              left: {($ Id.VSub_DollarName '$args')}
                                              right: {<2>}
                                            )
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (sh_array_literal
                                                left: <Id.Op_LParen _>
                                                words: [
                                                  {
                                                    (command_sub
                                                      left_token: <Id.Left_DollarParen '$('>
                                                      command_list: 
                                                        (command.CommandList
                                                          children: [
                                                            (C {<compgen>} {<-W>} 
                                                              {(SQ <'MASTER SLAVE NONE ACCEPT'>)} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                            )
                                                          ]
                                                        )
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [2145]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [2129 2142]
                                )
                              ]
                            )
                          ]
                          spids: [2122 2123 2174 -1]
                        )
                        (case_arm
                          pat_list: [{<ptype>}]
                          action: [
                            (C {<_count_args>})
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_eq
                                              left: {($ Id.VSub_DollarName '$args')}
                                              right: {<2>}
                                            )
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                  action: [(C {<_bluetooth_packet_types>})]
                                  spids: [2184 2197]
                                )
                              ]
                            )
                          ]
                          spids: [2177 2178 2206 -1]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
        )
        (C {<complete>} {<-F>} {<_hciconfig>} {<hciconfig>})
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (command.ShFunction
          name: _hciattach
          body: 
            (command.BraceGroup
              children: [
                (C {<local>} {<cur>} {<prev>} {<words>} {<cword>})
                (command.AndOr
                  ops: [Id.Op_DPipe]
                  children: [
                    (C {<_init_completion>})
                    (command.ControlFlow token:<Id.ControlFlow_Return return>)
                  ]
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                  right: {<-> <Id.Lit_Other '*'>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {<compgen>} {<-W>} {(SQ <'-n -p -t -b -s -l'>)} {<-->} 
                                                  {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [2272]
                            )
                          ]
                        )
                      ]
                      spids: [2253 2269]
                    )
                  ]
                  else_action: [
                    (C {<local>} {<args>})
                    (C {<_count_args>})
                    (command.Case
                      to_match: {($ Id.VSub_DollarName '$args')}
                      arms: [
                        (case_arm
                          pat_list: [{<1>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {<printf>} {(SQ <'%s\\n'>)} 
                                                      {</dev/tty> <Id.Lit_Star '*'>}
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [2318]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {<compgen>} {<-W>} 
                                                      {
                                                        (SQ <'${COMPREPLY[@]}\n'> 
                                                          <
'                    ${COMPREPLY[@]#/dev/}'
                                                          >
                                                        )
                                                      } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [2337]
                                )
                              ]
                            )
                          ]
                          spids: [2314 2315 2362 -1]
                        )
                        (case_arm
                          pat_list: [{<2>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {<compgen>} {<-W>} 
                                                      {
                                                        (SQ <'any ericsson digi xircom csr bboxes\n'> 
                                                          <
'                    swave bcsp 0x0105 0x080a 0x0160 0x0002'
                                                          >
                                                        )
                                                      } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [2369]
                                )
                              ]
                            )
                          ]
                          spids: [2365 2366 2394 -1]
                        )
                        (case_arm
                          pat_list: [{<3>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {<compgen>} {<-W>} 
                                                      {
                                                        (SQ 
                                                          <'9600 19200 38400 57600 115200 230400\n'> <'                    460800 921600'>
                                                        )
                                                      } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [2401]
                                )
                              ]
                            )
                          ]
                          spids: [2397 2398 2426 -1]
                        )
                        (case_arm
                          pat_list: [{<4>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {<compgen>} {<-W>} {(SQ <'flow noflow'>)} {<-->} 
                                                      {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [2433]
                                )
                              ]
                            )
                          ]
                          spids: [2429 2430 2457 -1]
                        )
                        (case_arm
                          pat_list: [{<5>}]
                          action: [(C {<_bluetooth_adresses>})]
                          spids: [2460 2461 2467 -1]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
        )
        (C {<complete>} {<-F>} {<_hciattach>} {<hciattach>})
      ]
    )
  ]
)