(CommandList
  children: [
    (C {(set)} {(-o)} {(errexit)})
    (C {(set)} {(-o)} {(nounset)})
    (C {(set)} {(-o)} {(pipefail)})
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:KUBE_ROOT)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [(C {(dirname)} {(DQ (${ VSub_Name BASH_SOURCE))})]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [64 72]
              ) (/../..)
            }
          spids: [63]
        )
      ]
      spids: [63]
    )
    (C {(source)} {(DQ (${ VSub_Name KUBE_ROOT) (/hack/lib/util.sh))})
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:EXCLUDED_PATTERNS)
          op: Equal
          rhs: 
            {
              (ArrayLiteralPart
                words: [
                  {(DQ (verify-all.sh))}
                  {(DQ (verify-linkcheck.sh))}
                  {(DQ (verify-test-owners.sh))}
                  {(DQ ("verify-*-dockerized.sh"))}
                ]
              )
            }
          spids: [88]
        )
      ]
      spids: [88]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:QUICK_PATTERNS)
          op: PlusEqual
          rhs: 
            {
              (ArrayLiteralPart
                words: [
                  {(DQ (verify-api-groups.sh))}
                  {(DQ (verify-bazel.sh))}
                  {(DQ (verify-boilerplate.sh))}
                  {(DQ (verify-generated-files-remake))}
                  {(DQ (verify-godep-licenses.sh))}
                  {(DQ (verify-gofmt.sh))}
                  {(DQ (verify-pkg-names.sh))}
                  {(DQ (verify-readonly-packages.sh))}
                  {(DQ (verify-staging-client-go.sh))}
                  {(DQ (verify-staging-imports.sh))}
                  {(DQ (verify-test-images.sh))}
                  {(DQ (verify-test-owners.sh))}
                ]
              )
            }
          spids: [136]
        )
      ]
      spids: [136]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:EXCLUDED_CHECKS)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (AndOr
                        children: [
                          (SimpleCommand
                            words: [
                              {(ls)}
                              {
                                (BracedVarSub
                                  token: <VSub_Name EXCLUDED_PATTERNS>
                                  bracket_op: (WholeArray op_id:Lit_At)
                                  suffix_op: 
                                    (PatSub
                                      pat: {}
                                      replace: 
                                        {(${ VSub_Name KUBE_ROOT) 
                                          (EscapedLiteralPart
                                            token: <Lit_EscapedChar "\\/">
                                          ) (hack) (EscapedLiteralPart token:<Lit_EscapedChar "\\/">)
                                        }
                                      do_all: False
                                      do_prefix: True
                                      do_suffix: False
                                    )
                                  spids: [206 220]
                                )
                              }
                            ]
                            redirects: [
                              (Redir
                                op_id: Redir_Great
                                fd: 2
                                arg_word: {(/dev/null)}
                                spids: [222]
                              )
                            ]
                          )
                          (C {(true)})
                        ]
                        op_id: Op_DPipe
                      )
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [203 228]
              )
            }
          spids: [202]
        )
      ]
      spids: [202]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:QUICK_CHECKS)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (AndOr
                        children: [
                          (SimpleCommand
                            words: [
                              {(ls)}
                              {
                                (BracedVarSub
                                  token: <VSub_Name QUICK_PATTERNS>
                                  bracket_op: (WholeArray op_id:Lit_At)
                                  suffix_op: 
                                    (PatSub
                                      pat: {}
                                      replace: 
                                        {(${ VSub_Name KUBE_ROOT) 
                                          (EscapedLiteralPart
                                            token: <Lit_EscapedChar "\\/">
                                          ) (hack) (EscapedLiteralPart token:<Lit_EscapedChar "\\/">)
                                        }
                                      do_all: False
                                      do_prefix: True
                                      do_suffix: False
                                    )
                                  spids: [234 248]
                                )
                              }
                            ]
                            redirects: [
                              (Redir
                                op_id: Redir_Great
                                fd: 2
                                arg_word: {(/dev/null)}
                                spids: [250]
                              )
                            ]
                          )
                          (C {(true)})
                        ]
                        op_id: Op_DPipe
                      )
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [231 256]
              )
            }
          spids: [230]
        )
      ]
      spids: [230]
    )
    (FuncDef
      name: is-excluded
      body: 
        (BraceGroup
          children: [
            (ForEach
              iter_name: e
              iter_words: [
                {
                  (BracedVarSub
                    token: <VSub_Name EXCLUDED_CHECKS>
                    bracket_op: (WholeArray op_id:Lit_At)
                    spids: [272 277]
                  )
                }
              ]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (BoolBinary
                                      op_id: BoolBinary_ef
                                      left: {($ VSub_Number "$1")}
                                      right: {(DQ ($ VSub_Name "$e"))}
                                    )
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [(ControlFlow token:<ControlFlow_Return return>)]
                          spids: [-1 298]
                        )
                      ]
                      spids: [-1 304]
                    )
                  ]
                  spids: [280 307]
                )
              spids: [271 278]
            )
            (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
          ]
          spids: [263]
        )
      spids: [259 262]
    )
    (FuncDef
      name: is-quick
      body: 
        (BraceGroup
          children: [
            (ForEach
              iter_name: e
              iter_words: [
                {
                  (BracedVarSub
                    token: <VSub_Name QUICK_CHECKS>
                    bracket_op: (WholeArray op_id:Lit_At)
                    spids: [330 335]
                  )
                }
              ]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (BoolBinary
                                      op_id: BoolBinary_ef
                                      left: {($ VSub_Number "$1")}
                                      right: {(DQ ($ VSub_Name "$e"))}
                                    )
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [(ControlFlow token:<ControlFlow_Return return>)]
                          spids: [-1 356]
                        )
                      ]
                      spids: [-1 362]
                    )
                  ]
                  spids: [338 365]
                )
              spids: [329 336]
            )
            (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
          ]
          spids: [321]
        )
      spids: [317 320]
    )
    (FuncDef
      name: run-cmd
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [(Sentence child:(C {(${ VSub_Name SILENT)}) terminator:<Op_Semi ";">)]
                  action: [
                    (Sentence
                      child: (C {(DQ ($ VSub_At "$@"))})
                      terminator: <Op_Amp "&">
                    )
                    (SimpleCommand
                      redirects: [(Redir op_id:Redir_Great fd:-1 arg_word:{(/dev/null)} spids:[397])]
                    )
                  ]
                  spids: [-1 389]
                )
              ]
              else_action: [(C {(DQ ($ VSub_At "$@"))})]
              spids: [402 410]
            )
          ]
          spids: [379]
        )
      spids: [375 378]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:FAILED_TESTS)
          op: Equal
          rhs: {(ArrayLiteralPart)}
          spids: [418]
        )
      ]
      spids: [418]
    )
    (FuncDef
      name: print-failed-tests
      body: 
        (BraceGroup
          children: [
            (C {(echo)} {(-e)} {(DQ ("========================"))})
            (C {(echo)} {(-e)} {(DQ (${ VSub_Name color_red) ("FAILED TESTS") (${ VSub_Name color_norm))})
            (C {(echo)} {(-e)} {(DQ ("========================"))})
            (ForEach
              iter_name: t
              iter_words: [
                {
                  (BracedVarSub
                    token: <VSub_Name FAILED_TESTS>
                    bracket_op: (WholeArray op_id:Lit_At)
                    spids: [469 474]
                  )
                }
              ]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (C {(echo)} {(-e)} 
                      {(DQ (${ VSub_Name color_red) (${ VSub_Name t) (${ VSub_Name color_norm))}
                    )
                  ]
                  spids: [477 497]
                )
              spids: [468 475]
            )
          ]
          spids: [427]
        )
      spids: [423 426]
    )
    (FuncDef
      name: run-checks
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              flags: ["'-r'"]
              pairs: [
                (assign_pair
                  lhs: (LhsName name:pattern)
                  op: Equal
                  rhs: {($ VSub_Number "$1")}
                  spids: [513]
                )
              ]
              spids: [509]
            )
            (Assignment
              keyword: Assign_Local
              flags: ["'-r'"]
              pairs: [
                (assign_pair
                  lhs: (LhsName name:runner)
                  op: Equal
                  rhs: {($ VSub_Number "$2")}
                  spids: [521]
                )
              ]
              spids: [517]
            )
            (ForEach
              iter_name: t
              iter_words: [
                {
                  (CommandSubPart
                    command_list: (CommandList children:[(C {(ls)} {(${ VSub_Name pattern)})])
                    left_token: <Left_CommandSub "$(">
                    spids: [532 538]
                  )
                }
              ]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: (C {(is-excluded)} {(DQ (${ VSub_Name t))})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(echo)} {(DQ ("Skipping ") (${ VSub_Name t))})
                            (ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                          spids: [-1 556]
                        )
                      ]
                      spids: [-1 572]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (AndOr
                                  children: [
                                    (C {(${ VSub_Name QUICK)})
                                    (Pipeline
                                      children: [(C {(is-quick)} {(DQ (${ VSub_Name t))})]
                                      negated: True
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(echo)} {(DQ ("Skipping ") (${ VSub_Name t) (" in quick mode"))})
                            (ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                          spids: [-1 595]
                        )
                      ]
                      spids: [-1 612]
                    )
                    (C {(echo)} {(-e)} {(DQ ("Verifying ") (${ VSub_Name t))})
                    (Assignment
                      keyword: Assign_Local
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:start)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [(C {(date)} {(Lit_Other "+") (Lit_Other "%") (s)})]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [630 636]
                              )
                            }
                          spids: [629]
                        )
                      ]
                      spids: [627]
                    )
                    (AndOr
                      children: [
                        (C {(run-cmd)} {(DQ (${ VSub_Name runner))} {(DQ (${ VSub_Name t))})
                        (AndOr
                          children: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:tr)
                                  op: Equal
                                  rhs: {($ VSub_QMark "$?")}
                                  spids: [655]
                                )
                              ]
                              spids: [655]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:tr)
                                  op: Equal
                                  rhs: {($ VSub_QMark "$?")}
                                  spids: [660]
                                )
                              ]
                              spids: [660]
                            )
                          ]
                          op_id: Op_DPipe
                        )
                      ]
                      op_id: Op_DAmp
                    )
                    (Assignment
                      keyword: Assign_Local
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:elapsed)
                          op: Equal
                          rhs: 
                            {
                              (ArithSubPart
                                anode: 
                                  (ArithBinary
                                    op_id: Arith_Minus
                                    left: 
                                      (ArithWord
                                        w: 
                                          {
                                            (CommandSubPart
                                              command_list: 
                                                (CommandList
                                                  children: [
                                                    (C {(date)} {(Lit_Other "+") (Lit_Other "%") (s)})
                                                  ]
                                                )
                                              left_token: <Left_CommandSub "$(">
                                              spids: [668 674]
                                            )
                                          }
                                      )
                                    right: (ArithWord w:{(${ VSub_Name start)})
                                  )
                                spids: [667 682]
                              )
                            }
                          spids: [666]
                        )
                      ]
                      spids: [664]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (BoolBinary
                                      op_id: BoolBinary_eq
                                      left: {(${ VSub_Name tr)}
                                      right: {(0)}
                                    )
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(echo)} {(-e)} 
                              {
                                (DQ (${ VSub_Name color_green) (SUCCESS) (${ VSub_Name color_norm) 
                                  ("  ") (${ VSub_Name t) (EscapedLiteralPart token:<Lit_EscapedChar "\\t">) (${ VSub_Name elapsed) (s)
                                )
                              }
                            )
                          ]
                          spids: [-1 700]
                        )
                      ]
                      else_action: [
                        (C {(echo)} {(-e)} 
                          {
                            (DQ (${ VSub_Name color_red) (FAILED) (${ VSub_Name color_norm) ("   ") 
                              (${ VSub_Name t) (EscapedLiteralPart token:<Lit_EscapedChar "\\t">) (${ VSub_Name elapsed) (s)
                            )
                          }
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [(assign_pair lhs:(LhsName name:ret) op:Equal rhs:{(1)} spids:[754])]
                          spids: [754]
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:FAILED_TESTS)
                              op: PlusEqual
                              rhs: {(ArrayLiteralPart words:[{(${ VSub_Name t)}])}
                              spids: [758]
                            )
                          ]
                          spids: [758]
                        )
                      ]
                      spids: [727 766]
                    )
                  ]
                  spids: [541 769]
                )
              spids: [531 -1]
            )
          ]
          spids: [506]
        )
      spids: [502 505]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:SILENT) op:Equal rhs:{(true)} spids:[774])]
      spids: [774]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:QUICK) op:Equal rhs:{(false)} spids:[777])]
      spids: [777]
    )
    (While
      cond: [(Sentence child:(C {(getopts)} {(DQ (":vQ"))} {(opt)}) terminator:<Op_Semi ";">)]
      body: 
        (DoGroup
          children: [
            (Case
              to_match: {(${ VSub_Name opt)}
              arms: [
                (case_arm
                  pat_list: [{(v)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:SILENT)
                          op: Equal
                          rhs: {(false)}
                          spids: [808]
                        )
                      ]
                      spids: [808]
                    )
                  ]
                  spids: [804 805 812 -1]
                )
                (case_arm
                  pat_list: [{(Q)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:QUICK)
                          op: Equal
                          rhs: {(true)}
                          spids: [819]
                        )
                      ]
                      spids: [819]
                    )
                  ]
                  spids: [815 816 823 -1]
                )
                (case_arm
                  pat_list: [{(EscapedLiteralPart token:<Lit_EscapedChar "\\?">)}]
                  action: [
                    (SimpleCommand
                      words: [{(echo)} {(DQ ("Invalid flag: -") (${ VSub_Name OPTARG))}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[839])]
                    )
                    (C {(exit)} {(1)})
                  ]
                  spids: [826 827 848 -1]
                )
              ]
              spids: [795 801 851]
            )
          ]
          spids: [792 853]
        )
    )
    (If
      arms: [
        (if_arm
          cond: [(Sentence child:(C {(${ VSub_Name SILENT)}) terminator:<Op_Semi ";">)]
          action: [
            (C {(echo)} {(DQ ("Running in silent mode, run with -v if you want to see script logs."))})
          ]
          spids: [-1 864]
        )
      ]
      spids: [-1 873]
    )
    (If
      arms: [
        (if_arm
          cond: [(Sentence child:(C {(${ VSub_Name QUICK)}) terminator:<Op_Semi ";">)]
          action: [(C {(echo)} {(DQ ("Running in quick mode (-Q flag). Only fast checks will run."))})]
          spids: [-1 884]
        )
      ]
      spids: [-1 893]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:ret) op:Equal rhs:{(0)} spids:[896])]
      spids: [896]
    )
    (C {(run-checks)} {(DQ (${ VSub_Name KUBE_ROOT) ("/hack/verify-*.sh"))} {(bash)})
    (C {(run-checks)} {(DQ (${ VSub_Name KUBE_ROOT) ("/hack/verify-*.py"))} {(python)})
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (DBracket
                  expr: (BoolBinary op_id:BoolBinary_eq left:{(${ VSub_Name ret)} right:{(1)})
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [(C {(print-failed-tests)})]
          spids: [-1 937]
        )
      ]
      spids: [-1 943]
    )
    (C {(exit)} {(${ VSub_Name ret)})
  ]
)