(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: 16777215
                          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: [16777215 107]
        )
      ]
      spids: [16777215 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: [16777215 194]
                        )
                      ]
                      spids: [16777215 207]
                    )
                  ]
                  spids: [174 210]
                )
              spids: [16777215 16777215]
            )
            (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:16777215 arg_word:{(2)} spids:[290])]
              spids: [262]
            )
            (C {(false)})
          ]
          spids: [16777215 259]
        )
      ]
      spids: [16777215 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) (/) (Lit_Other '\\') ('?||'))
                                  }
                                )
                              ]
                              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: [16777215 497]
                )
              ]
              spids: [16777215 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: [16777215 548]
                )
              ]
              spids: [16777215 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: [16777215 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:[679 689])
              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:16777215 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:16777215 arg_word:{(2)} spids:[800])]
              spids: [752]
            )
            (C {(false)})
          ]
          spids: [16777215 749]
        )
      ]
      spids: [16777215 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:16777215 arg_word:{(2)} spids:[879])]
              spids: [831]
            )
            (C {(false)})
          ]
          spids: [16777215 828]
        )
      ]
      spids: [16777215 885]
    )
  ]
)