(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/init.sh))})
    (C 
      {(kube) (Lit_Other ":") (Lit_Other ":") (golang) (Lit_Other ":") (Lit_Other ":") 
        (verify_go_version)
      }
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (Pipeline
                  children: [
                    (SimpleCommand
                      words: [{(which)} {(golint)}]
                      redirects: [(Redir op_id:Redir_Great fd:-1 arg_word:{(/dev/null)} spids:[102])]
                    )
                  ]
                  negated: True
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (C {(echo)} {(SQ <"Can not find golint, install with:">)})
            (C {(echo)} {(SQ <"go get -u github.com/golang/lint/golint">)})
            (C {(exit)} {(1)})
          ]
          spids: [-1 107]
        )
      ]
      spids: [-1 128]
    )
    (C {(cd)} {(DQ (${ VSub_Name KUBE_ROOT))})
    (FuncDef
      name: array_contains
      body: 
        (BraceGroup
          children: [
            (Sentence
              child: 
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:seeking)
                      op: Equal
                      rhs: {($ VSub_Number "$1")}
                      spids: [150]
                    )
                  ]
                  spids: [148]
                )
              terminator: <Op_Semi ";">
            )
            (C {(shift)})
            (Assignment
              keyword: Assign_Local
              pairs: [(assign_pair lhs:(LhsName name:in) op:Equal rhs:{(1)} spids:[162])]
              spids: [160]
            )
            (ForEach
              iter_name: element
              do_arg_iter: True
              body: 
                (DoGroup
                  children: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (BoolBinary
                                      op_id: BoolBinary_GlobDEqual
                                      left: {(DQ ($ VSub_Name "$element"))}
                                      right: {(DQ ($ VSub_Name "$seeking"))}
                                    )
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:in)
                                  op: Equal
                                  rhs: {(0)}
                                  spids: [197]
                                )
                              ]
                              spids: [197]
                            )
                            (ControlFlow token:<ControlFlow_Break break>)
                          ]
                          spids: [-1 194]
                        )
                      ]
                      spids: [-1 207]
                    )
                  ]
                  spids: [174 210]
                )
              spids: [-1 -1]
            )
            (ControlFlow token:<ControlFlow_Return return> arg_word:{($ VSub_Name "$in")})
          ]
          spids: [145]
        )
      spids: [140 144]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:failure_file)
          op: Equal
          rhs: {(DQ (${ VSub_Name KUBE_ROOT) (/hack/.golint_failures))}
          spids: [223]
        )
      ]
      spids: [223]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (Pipeline
                  children: [
                    (C {(diff)} {(-u)} {(DQ (${ VSub_Name failure_file))} 
                      {
                        (CommandSubPart
                          command_list: 
                            (CommandList
                              children: [
                                (SimpleCommand
                                  words: [{(sort)} {(DQ (${ VSub_Name failure_file))}]
                                  more_env: [(env_pair name:LC_ALL val:{(C)} spids:[246])]
                                )
                              ]
                            )
                          left_token: <Left_ProcSubIn "<(">
                          spids: [245 256]
                        )
                      }
                    )
                  ]
                  negated: True
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (BraceGroup
              children: [
                (C {(echo)})
                (C {(echo)} 
                  {(DQ ("hack/.golint_failures is not in alphabetical order. Please sort it:"))}
                )
                (C {(echo)})
                (C {(echo)} {(DQ ("  LC_ALL=C sort -o hack/.golint_failures hack/.golint_failures"))})
                (C {(echo)})
              ]
              redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[290])]
              spids: [262]
            )
            (C {(false)})
          ]
          spids: [-1 259]
        )
      ]
      spids: [-1 296]
    )
    (C {(export)} {(Lit_VarLike "IFS=") (SQ <Lit_EscapedChar "\\n">)})
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:all_packages)
          op: Equal
          rhs: 
            {
              (ArrayLiteralPart
                words: [
                  {
                    (CommandSubPart
                      command_list: 
                        (CommandList
                          children: [
                            (Pipeline
                              children: [
                                (C {(go)} {(list)} {(-e)} {(./...)})
                                (C {(egrep)} {(-v)} 
                                  {
                                    (DQ 
                                      (
"/(third_party|vendor|staging/src/k8s.io/client-go/pkg|generated|clientset_generated)"
                                      )
                                    )
                                  }
                                )
                                (C {(sed)} {(-e)} {(SQ <"s|^k8s.io/kubernetes/||">)} {(-e)} 
                                  {
                                    (DQ ("s|^_") (${ VSub_Name KUBE_ROOT) (/) 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\?">
                                      ) ("||")
                                    )
                                  }
                                )
                              ]
                              negated: False
                            )
                          ]
                        )
                      left_token: <Left_CommandSub "$(">
                      spids: [319 359]
                    )
                  }
                ]
              )
            }
          spids: [315]
        )
      ]
      spids: [315]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:failing_packages)
          op: Equal
          rhs: 
            {
              (ArrayLiteralPart
                words: [
                  {
                    (CommandSubPart
                      command_list: 
                        (CommandList
                          children: [(C {(cat)} {($ VSub_Name "$failure_file")})]
                        )
                      left_token: <Left_CommandSub "$(">
                      spids: [367 371]
                    )
                  }
                ]
              )
            }
          spids: [363]
        )
      ]
      spids: [363]
    )
    (C {(unset)} {(IFS)})
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:errors) op:Equal rhs:{(ArrayLiteralPart)} spids:[379])]
      spids: [379]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:not_failing)
          op: Equal
          rhs: {(ArrayLiteralPart)}
          spids: [383]
        )
      ]
      spids: [383]
    )
    (ForEach
      iter_name: p
      iter_words: [
        {
          (DQ 
            (BracedVarSub
              token: <VSub_Name all_packages>
              bracket_op: (WholeArray op_id:Lit_At)
              spids: [394 399]
            )
          )
        }
      ]
      do_arg_iter: False
      body: 
        (DoGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:failedLint)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (SimpleCommand
                                words: [{(golint)} {(DQ ($ VSub_Name "$p")) (/) (Lit_Other "*") (.go)}]
                                redirects: [
                                  (Redir
                                    op_id: Redir_Great
                                    fd: 2
                                    arg_word: {(/dev/null)}
                                    spids: [433]
                                  )
                                ]
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [423 435]
                      )
                    }
                  spids: [422]
                )
              ]
              spids: [422]
            )
            (AndOr
              children: [
                (C {(array_contains)} {(DQ ($ VSub_Name "$p"))} 
                  {
                    (DQ 
                      (BracedVarSub
                        token: <VSub_Name failing_packages>
                        bracket_op: (WholeArray op_id:Lit_At)
                        spids: [445 450]
                      )
                    )
                  }
                )
                (AndOr
                  children: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:in_failing)
                          op: Equal
                          rhs: {($ VSub_QMark "$?")}
                          spids: [455]
                        )
                      ]
                      spids: [455]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:in_failing)
                          op: Equal
                          rhs: {($ VSub_QMark "$?")}
                          spids: [460]
                        )
                      ]
                      spids: [460]
                    )
                  ]
                  op_id: Op_DPipe
                )
              ]
              op_id: Op_DAmp
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (AndOr
                          children: [
                            (DBracket
                              expr: (BoolUnary op_id:BoolUnary_n child:{(DQ (${ VSub_Name failedLint))})
                            )
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_ne
                                  left: {(DQ (${ VSub_Name in_failing))}
                                  right: {(DQ (0))}
                                )
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:errors)
                          op: PlusEqual
                          rhs: {(ArrayLiteralPart words:[{(DQ (${ VSub_Name failedLint))}])}
                          spids: [500]
                        )
                      ]
                      spids: [500]
                    )
                  ]
                  spids: [-1 497]
                )
              ]
              spids: [-1 512]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (AndOr
                          children: [
                            (DBracket
                              expr: (BoolUnary op_id:BoolUnary_z child:{(DQ (${ VSub_Name failedLint))})
                            )
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_eq
                                  left: {(DQ (${ VSub_Name in_failing))}
                                  right: {(DQ (0))}
                                )
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:not_failing)
                          op: PlusEqual
                          rhs: {(ArrayLiteralPart words:[{($ VSub_Name "$p")}])}
                          spids: [551]
                        )
                      ]
                      spids: [551]
                    )
                  ]
                  spids: [-1 548]
                )
              ]
              spids: [-1 559]
            )
          ]
          spids: [403 561]
        )
      spids: [392 401]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:gone) op:Equal rhs:{(ArrayLiteralPart)} spids:[567])]
      spids: [567]
    )
    (ForEach
      iter_name: p
      iter_words: [
        {
          (DQ 
            (BracedVarSub
              token: <VSub_Name failing_packages>
              bracket_op: (WholeArray op_id:Lit_At)
              spids: [578 583]
            )
          )
        }
      ]
      do_arg_iter: False
      body: 
        (DoGroup
          children: [
            (AndOr
              children: [
                (C {(array_contains)} {(DQ ($ VSub_Name "$p"))} 
                  {
                    (DQ 
                      (BracedVarSub
                        token: <VSub_Name all_packages>
                        bracket_op: (WholeArray op_id:Lit_At)
                        spids: [597 602]
                      )
                    )
                  }
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:gone)
                      op: PlusEqual
                      rhs: {(ArrayLiteralPart words:[{(DQ ($ VSub_Name "$p"))}])}
                      spids: [607]
                    )
                  ]
                  spids: [607]
                )
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [587 616]
        )
      spids: [576 585]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (C {(Lit_Other "[")} 
                  {
                    (BracedVarSub
                      token: <VSub_Name errors>
                      prefix_op: VSub_Pound
                      bracket_op: (WholeArray op_id:Lit_At)
                      spids: [626 632]
                    )
                  } {(-eq)} {(0)} {(Lit_Other "]")}
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [(C {(echo)} {(SQ <"Congratulations!  All Go source files have been linted.">)})]
          spids: [-1 641]
        )
      ]
      else_action: [
        (BraceGroup
          children: [
            (C {(echo)} {(DQ ("Errors from golint:"))})
            (ForEach
              iter_name: err
              iter_words: [
                {
                  (DQ 
                    (BracedVarSub
                      token: <VSub_Name errors>
                      bracket_op: (WholeArray op_id:Lit_At)
                      spids: [670 675]
                    )
                  )
                }
              ]
              do_arg_iter: False
              body: (DoGroup children:[(C {(echo)} {(DQ ($ VSub_Name "$err"))})] spids:[679689])
              spids: [668 677]
            )
            (C {(echo)})
            (C {(echo)} 
              {
                (SQ 
                  <
"Please review the above warnings. You can test via \"golint\" and commit the result."
                  >
                )
              }
            )
            (C {(echo)} 
              {
                (SQ 
                  <
"If the above warnings do not make sense, you can exempt this package from golint"
                  >
                )
              }
            )
            (C {(echo)} 
              {
                (SQ 
                  <
"checking by adding it to hack/.golint_failures (if your reviewer is okay with it)."
                  >
                )
              }
            )
            (C {(echo)})
          ]
          redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[721])]
          spids: [653]
        )
        (C {(false)})
      ]
      spids: [650 727]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (DBracket
                  expr: 
                    (BoolBinary
                      op_id: BoolBinary_gt
                      left: 
                        {
                          (BracedVarSub
                            token: <VSub_Name not_failing>
                            prefix_op: VSub_Pound
                            bracket_op: (WholeArray op_id:Lit_At)
                            spids: [734 740]
                          )
                        }
                      right: {(0)}
                    )
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (BraceGroup
              children: [
                (C {(echo)} 
                  {
                    (DQ 
                      (
"Some packages in hack/.golint_failures are passing golint. Please remove them."
                      )
                    )
                  }
                )
                (C {(echo)})
                (ForEach
                  iter_name: p
                  iter_words: [
                    {
                      (DQ 
                        (BracedVarSub
                          token: <VSub_Name not_failing>
                          bracket_op: (WholeArray op_id:Lit_At)
                          spids: [772 777]
                        )
                      )
                    }
                  ]
                  do_arg_iter: False
                  body: 
                    (DoGroup
                      children: [(C {(echo)} {(DQ ("  ") ($ VSub_Name "$p"))})]
                      spids: [781 792]
                    )
                  spids: [770 779]
                )
                (C {(echo)})
              ]
              redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[800])]
              spids: [752]
            )
            (C {(false)})
          ]
          spids: [-1 749]
        )
      ]
      spids: [-1 806]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (DBracket
                  expr: 
                    (BoolBinary
                      op_id: BoolBinary_gt
                      left: 
                        {
                          (BracedVarSub
                            token: <VSub_Name gone>
                            prefix_op: VSub_Pound
                            bracket_op: (WholeArray op_id:Lit_At)
                            spids: [813 819]
                          )
                        }
                      right: {(0)}
                    )
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (BraceGroup
              children: [
                (C {(echo)} 
                  {
                    (DQ 
                      (
"Some packages in hack/.golint_failures do not exist anymore. Please remove them."
                      )
                    )
                  }
                )
                (C {(echo)})
                (ForEach
                  iter_name: p
                  iter_words: [
                    {
                      (DQ 
                        (BracedVarSub
                          token: <VSub_Name gone>
                          bracket_op: (WholeArray op_id:Lit_At)
                          spids: [851 856]
                        )
                      )
                    }
                  ]
                  do_arg_iter: False
                  body: 
                    (DoGroup
                      children: [(C {(echo)} {(DQ ("  ") ($ VSub_Name "$p"))})]
                      spids: [860 871]
                    )
                  spids: [849 858]
                )
                (C {(echo)})
              ]
              redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[879])]
              spids: [831]
            )
            (C {(false)})
          ]
          spids: [-1 828]
        )
      ]
      spids: [-1 885]
    )
  ]
)