(command.CommandList
  children: [
    (command.ShFunction
      name: _iproute2_etc
      body: 
        (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 '$('>
                              child: 
                                (C {<compgen>} {<-W>} 
                                  {
                                    (DQ 
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (command.Simple
                                            words: [
                                              {<awk>}
                                              {(SQ <'!/#/ { print $2 }'>)}
                                              {<'/etc/iproute2/'> ($ Id.VSub_Number '$1')}
                                            ]
                                            redirects: [
                                              (redir
                                                op: <Id.Redir_Great '2>'>
                                                loc: (redir_loc.Fd fd:2)
                                                arg: {<'/dev/null'>}
                                              )
                                            ]
                                            do_fork: T
                                          )
                                      )
                                    )
                                  } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                )
                            )
                          }
                        ]
                      )
                    }
                  spids: [11]
                )
              ]
            )
          ]
        )
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (command.ShFunction
          name: _ip
          body: 
            (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: [{<-V>} {<-Version>} {<-rc>} {<-rcvbuf>}]
                      action: [
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [88 95 103 -1]
                    )
                    (case_arm
                      pat_list: [{<-f>} {<-family>}]
                      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 '$('>
                                          child: 
                                            (C {<compgen>} {<-W>} {(SQ <'inet inet6 ipx dnet link'>)} 
                                              {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [112]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [106 109 141 -1]
                    )
                    (case_arm
                      pat_list: [{<-b>} {<-batch>}]
                      action: [
                        (C {<_filedir>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [144 147 158 -1]
                    )
                    (case_arm
                      pat_list: [{<-force>}]
                      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 '$('>
                                          child: 
                                            (C {<compgen>} {<-W>} {(SQ <-batch>)} {<-->} 
                                              {(DQ ($ Id.VSub_DollarName '$cur'))}
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [165]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [161 162 194 -1]
                    )
                  ]
                )
                (C {<local>} {<subcword>} {<cmd>} {<subcmd>})
                (command.ForExpr
                  init: 
                    (arith_expr.BinaryAssign
                      op_id: Id.Arith_Equal
                      left: <Id.Lit_ArithVarLike subcword>
                      right: {<Id.Lit_Digits 1>}
                    )
                  cond: 
                    (arith_expr.Binary
                      op_id: Id.Arith_Less
                      left: <Id.Lit_ArithVarLike subcword>
                      right: 
                        (arith_expr.Binary
                          op_id: Id.Arith_Minus
                          left: 
                            {
                              (braced_var_sub
                                token: <Id.VSub_Name words>
                                prefix_op: (Id.VSub_Pound)
                                bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                              )
                            }
                          right: {<Id.Lit_Digits 1>}
                        )
                    )
                  update: 
                    (arith_expr.UnaryAssign
                      op_id: Id.Node_PostDPlus
                      child: <Id.Lit_ArithVarLike subcword>
                    )
                  body: 
                    (command.DoGroup
                      children: [
                        (command.AndOr
                          ops: [Id.Op_DAmp]
                          children: [
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: 
                                    {
                                      (braced_var_sub
                                        token: <Id.VSub_Name words>
                                        bracket_op: 
                                          (bracket_op.ArrayIndex
                                            expr: <Id.Lit_ArithVarLike subcword>
                                          )
                                      )
                                    }
                                  right: 
                                    {<Id.BoolUnary_b -b> 
                                      (word_part.ExtGlob
                                        op: <Id.ExtGlob_QMark '?('>
                                        arms: [{<atch>}]
                                      )
                                    }
                                )
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                              arg_word: {<0>}
                            )
                          ]
                        )
                        (command.AndOr
                          ops: [Id.Op_DAmp Id.Op_DAmp]
                          children: [
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_n
                                  child: {($ Id.VSub_DollarName '$cmd')}
                                )
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:subcmd)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (braced_var_sub
                                        token: <Id.VSub_Name words>
                                        bracket_op: 
                                          (bracket_op.ArrayIndex
                                            expr: <Id.Lit_ArithVarLike subcword>
                                          )
                                      )
                                    }
                                  spids: [279]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                        )
                        (command.AndOr
                          ops: [Id.Op_DAmp]
                          children: [
                            (command.DBracket
                              expr: 
                                (bool_expr.LogicalAnd
                                  left: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobNEqual
                                      left: 
                                        {
                                          (braced_var_sub
                                            token: <Id.VSub_Name words>
                                            bracket_op: 
                                              (bracket_op.ArrayIndex
                                                expr: <Id.Lit_ArithVarLike subcword>
                                              )
                                          )
                                        }
                                      right: {<-> <Id.Lit_Other '*'>}
                                    )
                                  right: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobNEqual
                                      left: 
                                        {
                                          (braced_var_sub
                                            token: <Id.VSub_Name words>
                                            bracket_op: 
                                              (bracket_op.ArrayIndex
                                                expr: 
                                                  (arith_expr.Binary
                                                    op_id: Id.Arith_Minus
                                                    left: <Id.Lit_ArithVarLike subcword>
                                                    right: {<Id.Lit_Digits 1>}
                                                  )
                                              )
                                          )
                                        }
                                      right: 
                                        {<-> 
                                          (word_part.ExtGlob
                                            op: <Id.ExtGlob_At '@('>
                                            arms: [
                                              {<f> 
                                                (word_part.ExtGlob
                                                  op: <Id.ExtGlob_QMark '?('>
                                                  arms: [{<amily>}]
                                                )
                                              }
                                              {<rc> 
                                                (word_part.ExtGlob
                                                  op: <Id.ExtGlob_QMark '?('>
                                                  arms: [{<vbuf>}]
                                                )
                                              }
                                            ]
                                          )
                                        }
                                    )
                                )
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:cmd)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (braced_var_sub
                                        token: <Id.VSub_Name words>
                                        bracket_op: 
                                          (bracket_op.ArrayIndex
                                            expr: <Id.Lit_ArithVarLike subcword>
                                          )
                                      )
                                    }
                                  spids: [340]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Unary
                                      op_id: Id.BoolUnary_z
                                      child: {($ Id.VSub_DollarName '$cmd')}
                                    )
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      action: [
                        (command.Case
                          to_match: {($ Id.VSub_DollarName '$cur')}
                          arms: [
                            (case_arm
                              pat_list: [{<-> <Id.Lit_Star '*'>}]
                              action: [
                                (C {<local>} 
                                  {<Id.Lit_VarLike 'c='> 
                                    (DQ <'-Version -statistics -details -resolve -family\n'> 
                                      <'                    -oneline -timestamp -batch -rcvbuf'>
                                    )
                                  }
                                )
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_eq
                                          left: {($ Id.VSub_DollarName '$cword')}
                                          right: {<1>}
                                        )
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:c)
                                          op: assign_op.PlusEqual
                                          rhs: {(DQ <' -force'>)}
                                          spids: [400]
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (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 '$('>
                                                  child: 
                                                    (C {<compgen>} {<-W>} 
                                                      {(DQ ($ Id.VSub_DollarName '$c'))} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [406]
                                    )
                                  ]
                                )
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Return return>
                                  arg_word: {<0>}
                                )
                              ]
                              spids: [374 376 435 -1]
                            )
                            (case_arm
                              pat_list: [{<Id.Lit_Star '*'>}]
                              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 '$('>
                                                  child: 
                                                    (C {<compgen>} {<-W>} 
                                                      {
                                                        (DQ <'help '> 
                                                          (command_sub
                                                            left_token: <Id.Left_DollarParen '$('>
                                                            child: 
                                                              (command.Pipeline
                                                                children: [
                                                                  (command.Simple
                                                                    words: [{<ip>} {<help>}]
                                                                    redirects: [
                                                                      (redir
                                                                        op: <Id.Redir_GreatAnd '2>&'>
                                                                        loc: (redir_loc.Fd fd:2)
                                                                        arg: {<1>}
                                                                      )
                                                                    ]
                                                                    do_fork: T
                                                                  )
                                                                  (C {<sed>} {<-e>} 
                                                                    {(SQ <'/OBJECT := /,/}/!d'>)} {<-e>} {(SQ <'s/.*{//'>)} {<-e>} {(SQ <'s/}.*//'>)} {<-e>} {(SQ <'s/|//g'>)}
                                                                  )
                                                                ]
                                                                negated: F
                                                              )
                                                          )
                                                        )
                                                      } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [442]
                                    )
                                  ]
                                )
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Return return>
                                  arg_word: {<0>}
                                )
                              ]
                              spids: [438 439 513 -1]
                            )
                          ]
                        )
                      ]
                      spids: [353 364]
                    )
                  ]
                )
                (command.AndOr
                  ops: [Id.Op_DAmp]
                  children: [
                    (command.DBracket
                      expr: 
                        (bool_expr.Binary
                          op_id: Id.BoolBinary_GlobDEqual
                          left: {($ Id.VSub_DollarName '$subcmd')}
                          right: {<help>}
                        )
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                )
                (command.Case
                  to_match: {($ Id.VSub_DollarName '$cmd')}
                  arms: [
                    (case_arm
                      pat_list: [{<link>}]
                      action: [
                        (command.Case
                          to_match: {($ Id.VSub_DollarName '$subcmd')}
                          arms: [
                            (case_arm
                              pat_list: [{<add>}]
                              spids: [559 560 567 -1]
                            )
                            (case_arm
                              pat_list: [{<delete>}]
                              action: [
                                (command.Case
                                  to_match: 
                                    {
                                      (word_part.ArithSub
                                        anode: 
                                          (arith_expr.Binary
                                            op_id: Id.Arith_Minus
                                            left: {($ Id.VSub_DollarName '$cword')}
                                            right: {($ Id.VSub_DollarName '$subcword')}
                                          )
                                      )
                                    }
                                  arms: [
                                    (case_arm
                                      pat_list: [{<1>}]
                                      action: [(C {<_available_interfaces>})]
                                      spids: [586 587 593 -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 '$('>
                                                          child: 
                                                            (C {<compgen>} {<-W>} {(SQ <type>)} {<-->} 
                                                              {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                            )
                                                        )
                                                      }
                                                    ]
                                                  )
                                                }
                                              spids: [600]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [596 597 624 -1]
                                    )
                                    (case_arm
                                      pat_list: [{<3>}]
                                      action: [
                                        (command.AndOr
                                          ops: [Id.Op_DAmp]
                                          children: [
                                            (command.DBracket
                                              expr: 
                                                (bool_expr.Binary
                                                  op_id: Id.BoolBinary_GlobDEqual
                                                  left: {($ Id.VSub_DollarName '$prev')}
                                                  right: {<type>}
                                                )
                                            )
                                            (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 '$('>
                                                              child: 
                                                                (C {<compgen>} {<-W>} 
                                                                  {
                                                                    (SQ <'vlan veth vcan dummy\n'> 
                                                                      <
'                                    ifb macvlan can'
                                                                      >
                                                                    )
                                                                  } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                                )
                                                            )
                                                          }
                                                        ]
                                                      )
                                                    }
                                                  spids: [645]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [627 628 670 -1]
                                    )
                                  ]
                                )
                              ]
                              spids: [570 571 676 -1]
                            )
                            (case_arm
                              pat_list: [{<set>}]
                              action: [
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (command.Sentence
                                              child: 
                                                (command.DBracket
                                                  expr: 
                                                    (bool_expr.Binary
                                                      op_id: Id.BoolBinary_eq
                                                      left: 
                                                        {($ Id.VSub_DollarName '$cword') <-> 
                                                          ($ Id.VSub_DollarName '$subcword')
                                                        }
                                                      right: {<1>}
                                                    )
                                                )
                                              terminator: <Id.Op_Semi _>
                                            )
                                          ]
                                        )
                                      action: [(C {<_available_interfaces>})]
                                      spids: [683 698]
                                    )
                                  ]
                                  else_action: [
                                    (command.Case
                                      to_match: {($ Id.VSub_DollarName '$prev')}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {<arp>}
                                            {<dynamic>}
                                            {<multicast>}
                                            {<allmulticast>}
                                            {<promisc>}
                                            {<trailers>}
                                          ]
                                          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 '$('>
                                                              child: 
                                                                (C {<compgen>} {<-W>} {(SQ <'on off'>)} 
                                                                  {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                                )
                                                            )
                                                          }
                                                        ]
                                                      )
                                                    }
                                                  spids: [730]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [714 727 756 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {<txqueuelen>}
                                            {<name>}
                                            {<address>}
                                            {<broadcast>}
                                            {<mtu>}
                                            {<netns>}
                                            {<alias>}
                                          ]
                                          spids: [759 772 775 -1]
                                        )
                                        (case_arm
                                          pat_list: [{<Id.Lit_Star '*'>}]
                                          action: [
                                            (C {<local>} 
                                              {<Id.Lit_VarLike 'c='> 
                                                (DQ <'arp dynamic multicast allmulticast\n'> 
                                                  <
'                                    promisc trailers txqueuelen name address\n'
                                                  > <'                                    broadcast mtu netns alias'>
                                                )
                                              }
                                            )
                                            (command.AndOr
                                              ops: [Id.Op_DAmp]
                                              children: [
                                                (command.DBracket
                                                  expr: 
                                                    (bool_expr.Binary
                                                      op_id: Id.BoolBinary_GlobNEqual
                                                      left: {($ Id.VSub_DollarName '$prev')}
                                                      right: 
                                                        {
                                                          (word_part.ExtGlob
                                                            op: <Id.ExtGlob_At '@('>
                                                            arms: [{<up>} {<down>}]
                                                          )
                                                        }
                                                    )
                                                )
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:c)
                                                      op: assign_op.PlusEqual
                                                      rhs: {(DQ <' up down'>)}
                                                      spids: [808]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (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 '$('>
                                                              child: 
                                                                (C {<compgen>} {<-W>} 
                                                                  {(DQ ($ Id.VSub_DollarName '$c'))} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                                )
                                                            )
                                                          }
                                                        ]
                                                      )
                                                    }
                                                  spids: [814]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [778 779 838 -1]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              spids: [679 680 847 -1]
                            )
                            (case_arm
                              pat_list: [{<show>}]
                              action: [
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (command.Sentence
                                              child: 
                                                (command.DBracket
                                                  expr: 
                                                    (bool_expr.Binary
                                                      op_id: Id.BoolBinary_eq
                                                      left: {($ Id.VSub_DollarName '$cword')}
                                                      right: 
                                                        {($ Id.VSub_DollarName '$subcword') 
                                                          <Id.Lit_Other '+'> <1>
                                                        }
                                                    )
                                                )
                                              terminator: <Id.Op_Semi _>
                                            )
                                          ]
                                        )
                                      action: [
                                        (C {<_available_interfaces>})
                                        (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 '$('>
                                                          child: 
                                                            (C {<compgen>} {<-W>} {(SQ <'dev group up'>)} 
                                                              {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                            )
                                                        )
                                                      }
                                                    ]
                                                  )
                                                }
                                              spids: [875]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [854 869]
                                    )
                                    (if_arm
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (command.Sentence
                                              child: 
                                                (command.DBracket
                                                  expr: 
                                                    (bool_expr.Binary
                                                      op_id: Id.BoolBinary_GlobDEqual
                                                      left: {($ Id.VSub_DollarName '$prev')}
                                                      right: {<dev>}
                                                    )
                                                )
                                              terminator: <Id.Op_Semi _>
                                            )
                                          ]
                                        )
                                      action: [(C {<_available_interfaces>})]
                                      spids: [899 912]
                                    )
                                    (if_arm
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (command.Sentence
                                              child: 
                                                (command.DBracket
                                                  expr: 
                                                    (bool_expr.Binary
                                                      op_id: Id.BoolBinary_GlobDEqual
                                                      left: {($ Id.VSub_DollarName '$prev')}
                                                      right: {<group>}
                                                    )
                                                )
                                              terminator: <Id.Op_Semi _>
                                            )
                                          ]
                                        )
                                      action: [(C {<_iproute2_etc>} {<group>})]
                                      spids: [918 931]
                                    )
                                  ]
                                )
                              ]
                              spids: [850 851 942 -1]
                            )
                            (case_arm
                              pat_list: [{<Id.Lit_Star '*'>}]
                              action: [
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_eq
                                          left: {($ Id.VSub_DollarName '$cword')}
                                          right: {($ Id.VSub_DollarName '$subcword')}
                                        )
                                    )
                                    (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 '$('>
                                                      child: 
                                                        (C {<compgen>} {<-W>} 
                                                          {(SQ <'help add delete set show'>)} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                        )
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [963]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              spids: [945 946 989 -1]
                            )
                          ]
                        )
                      ]
                      spids: [548 549 995 -1]
                    )
                    (case_arm
                      pat_list: [{<addr>}]
                      action: [
                        (command.Case
                          to_match: {($ Id.VSub_DollarName '$subcmd')}
                          arms: [
                            (case_arm
                              pat_list: [{<add>} {<change>} {<replace>}]
                              action: [
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (command.Sentence
                                              child: 
                                                (command.DBracket
                                                  expr: 
                                                    (bool_expr.Binary
                                                      op_id: Id.BoolBinary_GlobDEqual
                                                      left: {($ Id.VSub_DollarName '$prev')}
                                                      right: {<dev>}
                                                    )
                                                )
                                              terminator: <Id.Op_Semi _>
                                            )
                                          ]
                                        )
                                      action: [(C {<_available_interfaces>})]
                                      spids: [1018 1031]
                                    )
                                    (if_arm
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (command.Sentence
                                              child: 
                                                (command.DBracket
                                                  expr: 
                                                    (bool_expr.Binary
                                                      op_id: Id.BoolBinary_GlobDEqual
                                                      left: {($ Id.VSub_DollarName '$prev')}
                                                      right: {<scope>}
                                                    )
                                                )
                                              terminator: <Id.Op_Semi _>
                                            )
                                          ]
                                        )
                                      action: [(C {<_iproute2_etc>} {<rt_scopes>})]
                                      spids: [1037 1050]
                                    )
                                  ]
                                  else_action: [(C {<Id.Lit_Colon ':'>})]
                                )
                              ]
                              spids: [1010 1015 1070 -1]
                            )
                            (case_arm
                              pat_list: [{<del>}]
                              action: [
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (command.Sentence
                                              child: 
                                                (command.DBracket
                                                  expr: 
                                                    (bool_expr.Binary
                                                      op_id: Id.BoolBinary_GlobDEqual
                                                      left: {($ Id.VSub_DollarName '$prev')}
                                                      right: {<dev>}
                                                    )
                                                )
                                              terminator: <Id.Op_Semi _>
                                            )
                                          ]
                                        )
                                      action: [(C {<_available_interfaces>})]
                                      spids: [1077 1090]
                                    )
                                    (if_arm
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (command.Sentence
                                              child: 
                                                (command.DBracket
                                                  expr: 
                                                    (bool_expr.Binary
                                                      op_id: Id.BoolBinary_GlobDEqual
                                                      left: {($ Id.VSub_DollarName '$prev')}
                                                      right: {<scope>}
                                                    )
                                                )
                                              terminator: <Id.Op_Semi _>
                                            )
                                          ]
                                        )
                                      action: [(C {<_iproute2_etc>} {<rt_scopes>})]
                                      spids: [1096 1109]
                                    )
                                  ]
                                  else_action: [(C {<Id.Lit_Colon ':'>})]
                                )
                              ]
                              spids: [1073 1074 1129 -1]
                            )
                            (case_arm
                              pat_list: [{<show>} {<flush>}]
                              action: [
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (command.Sentence
                                              child: 
                                                (command.DBracket
                                                  expr: 
                                                    (bool_expr.Binary
                                                      op_id: Id.BoolBinary_eq
                                                      left: {($ Id.VSub_DollarName '$cword')}
                                                      right: 
                                                        {($ Id.VSub_DollarName '$subcword') 
                                                          <Id.Lit_Other '+'> <1>
                                                        }
                                                    )
                                                )
                                              terminator: <Id.Op_Semi _>
                                            )
                                          ]
                                        )
                                      action: [
                                        (C {<_available_interfaces>})
                                        (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 '$('>
                                                          child: 
                                                            (C {<compgen>} {<-W>} 
                                                              {
                                                                (SQ <'dev scope to label dynamic\n'> 
                                                                  <
'                            permanent tentative deprecated dadfailed temporary\n'
                                                                  > <'                            primary secondary up'>
                                                                )
                                                              } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                            )
                                                        )
                                                      }
                                                    ]
                                                  )
                                                }
                                              spids: [1159]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [1138 1153]
                                    )
                                    (if_arm
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (command.Sentence
                                              child: 
                                                (command.DBracket
                                                  expr: 
                                                    (bool_expr.Binary
                                                      op_id: Id.BoolBinary_GlobDEqual
                                                      left: {($ Id.VSub_DollarName '$prev')}
                                                      right: {<dev>}
                                                    )
                                                )
                                              terminator: <Id.Op_Semi _>
                                            )
                                          ]
                                        )
                                      action: [(C {<_available_interfaces>})]
                                      spids: [1185 1198]
                                    )
                                    (if_arm
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (command.Sentence
                                              child: 
                                                (command.DBracket
                                                  expr: 
                                                    (bool_expr.Binary
                                                      op_id: Id.BoolBinary_GlobDEqual
                                                      left: {($ Id.VSub_DollarName '$prev')}
                                                      right: {<scope>}
                                                    )
                                                )
                                              terminator: <Id.Op_Semi _>
                                            )
                                          ]
                                        )
                                      action: [(C {<_iproute2_etc>} {<rt_scopes>})]
                                      spids: [1204 1217]
                                    )
                                  ]
                                )
                              ]
                              spids: [1132 1135 1228 -1]
                            )
                            (case_arm
                              pat_list: [{<Id.Lit_Star '*'>}]
                              action: [
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_eq
                                          left: {($ Id.VSub_DollarName '$cword')}
                                          right: {($ Id.VSub_DollarName '$subcword')}
                                        )
                                    )
                                    (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 '$('>
                                                      child: 
                                                        (C {<compgen>} {<-W>} 
                                                          {
                                                            (SQ <'help add change replace del\n'> 
                                                              <
'                            show flush'
                                                              >
                                                            )
                                                          } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                        )
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [1249]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              spids: [1231 1232 1274 -1]
                            )
                          ]
                        )
                      ]
                      spids: [999 1000 1280 -1]
                    )
                    (case_arm
                      pat_list: [{<addrlabel>}]
                      action: [
                        (command.Case
                          to_match: {($ Id.VSub_DollarName '$subcmd')}
                          arms: [
                            (case_arm
                              pat_list: [{<list>} {<add>} {<del>} {<flush>}]
                              action: [
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (command.Sentence
                                              child: 
                                                (command.DBracket
                                                  expr: 
                                                    (bool_expr.Binary
                                                      op_id: Id.BoolBinary_GlobDEqual
                                                      left: {($ Id.VSub_DollarName '$prev')}
                                                      right: {<dev>}
                                                    )
                                                )
                                              terminator: <Id.Op_Semi _>
                                            )
                                          ]
                                        )
                                      action: [(C {<_available_interfaces>})]
                                      spids: [1305 1318]
                                    )
                                  ]
                                  else_action: [(C {<Id.Lit_Colon ':'>})]
                                )
                              ]
                              spids: [1295 1302 1336 -1]
                            )
                            (case_arm
                              pat_list: [{<Id.Lit_Star '*'>}]
                              action: [
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_eq
                                          left: {($ Id.VSub_DollarName '$cword')}
                                          right: {($ Id.VSub_DollarName '$subcword')}
                                        )
                                    )
                                    (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 '$('>
                                                      child: 
                                                        (C {<compgen>} {<-W>} 
                                                          {(SQ <'help list add del flush'>)} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                        )
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [1357]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              spids: [1339 1340 1383 -1]
                            )
                          ]
                        )
                      ]
                      spids: [1284 1285 1389 -1]
                    )
                    (case_arm
                      pat_list: [{<route>}]
                      action: [
                        (command.Case
                          to_match: {($ Id.VSub_DollarName '$subcmd')}
                          arms: [
                            (case_arm
                              pat_list: [{<list>} {<flush>}]
                              action: [
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (command.Sentence
                                              child: 
                                                (command.DBracket
                                                  expr: 
                                                    (bool_expr.Binary
                                                      op_id: Id.BoolBinary_GlobDEqual
                                                      left: {($ Id.VSub_DollarName '$prev')}
                                                      right: {<proto>}
                                                    )
                                                )
                                              terminator: <Id.Op_Semi _>
                                            )
                                          ]
                                        )
                                      action: [(C {<_iproute2_etc>} {<rt_protos>})]
                                      spids: [1410 1423]
                                    )
                                  ]
                                  else_action: [(C {<Id.Lit_Colon ':'>})]
                                )
                              ]
                              spids: [1404 1407 1443 -1]
                            )
                            (case_arm
                              pat_list: [{<get>}]
                              spids: [1446 1447 1454 -1]
                            )
                            (case_arm
                              pat_list: [{<add>} {<del>} {<change>} {<append>} {<replace>} {<monitor>}]
                              spids: [1457 1468 1475 -1]
                            )
                            (case_arm
                              pat_list: [{<Id.Lit_Star '*'>}]
                              action: [
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_eq
                                          left: {($ Id.VSub_DollarName '$cword')}
                                          right: {($ Id.VSub_DollarName '$subcword')}
                                        )
                                    )
                                    (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 '$('>
                                                      child: 
                                                        (C {<compgen>} {<-W>} 
                                                          {
                                                            (SQ <'help list flush get add del\n'> 
                                                              <
'                            change append replace monitor'
                                                              >
                                                            )
                                                          } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                        )
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [1496]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              spids: [1478 1479 1521 -1]
                            )
                          ]
                        )
                      ]
                      spids: [1393 1394 1527 -1]
                    )
                    (case_arm
                      pat_list: [{<rule>}]
                      action: [
                        (command.Case
                          to_match: {($ Id.VSub_DollarName '$subcmd')}
                          arms: [
                            (case_arm
                              pat_list: [{<add>} {<del>}]
                              spids: [1542 1545 1552 -1]
                            )
                            (case_arm
                              pat_list: [{<flush>} {<show>} {<list>} {<lst>}]
                              spids: [1555 1562 1565 -1]
                            )
                            (case_arm
                              pat_list: [{<Id.Lit_Star '*'>}]
                              action: [
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_eq
                                          left: {($ Id.VSub_DollarName '$cword')}
                                          right: {($ Id.VSub_DollarName '$subcword')}
                                        )
                                    )
                                    (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 '$('>
                                                      child: 
                                                        (C {<compgen>} {<-W>} 
                                                          {(SQ <'help list add del flush'>)} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                        )
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [1586]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              spids: [1568 1569 1612 -1]
                            )
                          ]
                        )
                      ]
                      spids: [1531 1532 1618 -1]
                    )
                    (case_arm
                      pat_list: [{<neigh>}]
                      action: [
                        (command.Case
                          to_match: {($ Id.VSub_DollarName '$subcmd')}
                          arms: [
                            (case_arm
                              pat_list: [{<add>} {<del>} {<change>} {<replace>}]
                              spids: [1633 1640 1647 -1]
                            )
                            (case_arm
                              pat_list: [{<show>} {<flush>}]
                              spids: [1650 1653 1660 -1]
                            )
                            (case_arm
                              pat_list: [{<Id.Lit_Star '*'>}]
                              action: [
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_eq
                                          left: {($ Id.VSub_DollarName '$cword')}
                                          right: {($ Id.VSub_DollarName '$subcword')}
                                        )
                                    )
                                    (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 '$('>
                                                      child: 
                                                        (C {<compgen>} {<-W>} 
                                                          {
                                                            (SQ <'help add del change replace\n'> 
                                                              <
'                            show flush'
                                                              >
                                                            )
                                                          } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                        )
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [1681]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              spids: [1663 1664 1706 -1]
                            )
                          ]
                        )
                      ]
                      spids: [1622 1623 1712 -1]
                    )
                    (case_arm
                      pat_list: [{<ntable>}]
                      action: [
                        (command.Case
                          to_match: {($ Id.VSub_DollarName '$subcmd')}
                          arms: [
                            (case_arm
                              pat_list: [{<change>}]
                              spids: [1727 1728 1735 -1]
                            )
                            (case_arm
                              pat_list: [{<show>}]
                              spids: [1738 1739 1746 -1]
                            )
                            (case_arm
                              pat_list: [{<Id.Lit_Star '*'>}]
                              action: [
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_eq
                                          left: {($ Id.VSub_DollarName '$cword')}
                                          right: {($ Id.VSub_DollarName '$subcword')}
                                        )
                                    )
                                    (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 '$('>
                                                      child: 
                                                        (C {<compgen>} {<-W>} {(SQ <'help change show'>)} 
                                                          {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                        )
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [1767]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              spids: [1749 1750 1793 -1]
                            )
                          ]
                        )
                      ]
                      spids: [1716 1717 1799 -1]
                    )
                    (case_arm
                      pat_list: [{<tunnel>}]
                      action: [
                        (command.Case
                          to_match: {($ Id.VSub_DollarName '$subcmd')}
                          arms: [
                            (case_arm
                              pat_list: [{<show>}]
                              spids: [1814 1815 1818 -1]
                            )
                            (case_arm
                              pat_list: [{<add>} {<change>} {<del>} {<prl>} {<6rd>}]
                              spids: [1821 1830 1837 -1]
                            )
                            (case_arm
                              pat_list: [{<Id.Lit_Star '*'>}]
                              action: [
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_eq
                                          left: {($ Id.VSub_DollarName '$cword')}
                                          right: {($ Id.VSub_DollarName '$subcword')}
                                        )
                                    )
                                    (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 '$('>
                                                      child: 
                                                        (C {<compgen>} {<-W>} 
                                                          {
                                                            (SQ <'help add change del show prl\n'> 
                                                              <'                            6rd'>
                                                            )
                                                          } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                        )
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [1858]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              spids: [1840 1841 1883 -1]
                            )
                          ]
                        )
                      ]
                      spids: [1803 1804 1889 -1]
                    )
                    (case_arm
                      pat_list: [{<maddr>}]
                      action: [
                        (command.Case
                          to_match: {($ Id.VSub_DollarName '$subcmd')}
                          arms: [
                            (case_arm
                              pat_list: [{<add>} {<del>}]
                              spids: [1904 1907 1914 -1]
                            )
                            (case_arm
                              pat_list: [{<show>}]
                              action: [
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (command.Sentence
                                              child: 
                                                (command.DBracket
                                                  expr: 
                                                    (bool_expr.LogicalOr
                                                      left: 
                                                        (bool_expr.Binary
                                                          op_id: Id.BoolBinary_eq
                                                          left: {($ Id.VSub_DollarName '$cword')}
                                                          right: 
                                                            {($ Id.VSub_DollarName '$subcword') 
                                                              <Id.Lit_Other '+'> <1>
                                                            }
                                                        )
                                                      right: 
                                                        (bool_expr.Binary
                                                          op_id: Id.BoolBinary_GlobDEqual
                                                          left: {($ Id.VSub_DollarName '$prev')}
                                                          right: {<dev>}
                                                        )
                                                    )
                                                )
                                              terminator: <Id.Op_Semi _>
                                            )
                                          ]
                                        )
                                      action: [
                                        (C {<_available_interfaces>})
                                        (command.AndOr
                                          ops: [Id.Op_DAmp]
                                          children: [
                                            (command.DBracket
                                              expr: 
                                                (bool_expr.Binary
                                                  op_id: Id.BoolBinary_GlobNEqual
                                                  left: {($ Id.VSub_DollarName '$prev')}
                                                  right: {<dev>}
                                                )
                                            )
                                            (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 '$('>
                                                              child: 
                                                                (C {<compgen>} {<-W>} 
                                                                  {(SQ <'${COMPREPLY[@]} dev'>)} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                                )
                                                            )
                                                          }
                                                        ]
                                                      )
                                                    }
                                                  spids: [1964]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [1921 1944]
                                    )
                                  ]
                                )
                              ]
                              spids: [1917 1918 1993 -1]
                            )
                            (case_arm
                              pat_list: [{<Id.Lit_Star '*'>}]
                              action: [
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_eq
                                          left: {($ Id.VSub_DollarName '$cword')}
                                          right: {($ Id.VSub_DollarName '$subcword')}
                                        )
                                    )
                                    (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 '$('>
                                                      child: 
                                                        (C {<compgen>} {<-W>} 
                                                          {(SQ <'help add del show'>)} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                        )
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [2014]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              spids: [1996 1997 2040 -1]
                            )
                          ]
                        )
                      ]
                      spids: [1893 1894 2046 -1]
                    )
                    (case_arm
                      pat_list: [{<mroute>}]
                      action: [
                        (command.Case
                          to_match: {($ Id.VSub_DollarName '$subcmd')}
                          arms: [
                            (case_arm
                              pat_list: [{<show>}]
                              spids: [2061 2062 2069 -1]
                            )
                            (case_arm
                              pat_list: [{<Id.Lit_Star '*'>}]
                              action: [
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_eq
                                          left: {($ Id.VSub_DollarName '$cword')}
                                          right: {($ Id.VSub_DollarName '$subcword')}
                                        )
                                    )
                                    (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 '$('>
                                                      child: 
                                                        (C {<compgen>} {<-W>} {(SQ <'help show'>)} {<-->} 
                                                          {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                        )
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [2090]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              spids: [2072 2073 2114 -1]
                            )
                          ]
                        )
                      ]
                      spids: [2050 2051 2120 -1]
                    )
                    (case_arm
                      pat_list: [{<monitor>}]
                      action: [
                        (command.Case
                          to_match: {($ Id.VSub_DollarName '$subcmd')}
                          arms: [
                            (case_arm
                              pat_list: [{<all>}]
                              spids: [2135 2136 2138 -1]
                            )
                            (case_arm
                              pat_list: [{<Id.Lit_Star '*'>}]
                              action: [
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_eq
                                          left: {($ Id.VSub_DollarName '$cword')}
                                          right: {($ Id.VSub_DollarName '$subcword')}
                                        )
                                    )
                                    (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 '$('>
                                                      child: 
                                                        (C {<compgen>} {<-W>} {(SQ <'help all'>)} {<-->} 
                                                          {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                        )
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [2159]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              spids: [2141 2142 2183 -1]
                            )
                          ]
                        )
                      ]
                      spids: [2124 2125 2189 -1]
                    )
                    (case_arm
                      pat_list: [{<xfrm>}]
                      action: [
                        (command.Case
                          to_match: {($ Id.VSub_DollarName '$subcmd')}
                          arms: [
                            (case_arm
                              pat_list: [{<state>} {<policy>} {<monitor>}]
                              spids: [2204 2209 2216 -1]
                            )
                            (case_arm
                              pat_list: [{<Id.Lit_Star '*'>}]
                              action: [
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_eq
                                          left: {($ Id.VSub_DollarName '$cword')}
                                          right: {($ Id.VSub_DollarName '$subcword')}
                                        )
                                    )
                                    (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 '$('>
                                                      child: 
                                                        (C {<compgen>} {<-W>} 
                                                          {(SQ <'state policy monitor'>)} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                        )
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [2237]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              spids: [2219 2220 2263 -1]
                            )
                          ]
                        )
                      ]
                      spids: [2193 2194 2269 -1]
                    )
                  ]
                )
              ]
            )
        )
        (C {<complete>} {<-F>} {<_ip>} {<ip>})
      ]
    )
  ]
)