(command.CommandList
  children: [
    (C {<set>} {<-o>} {<errexit>})
    (C {<set>} {<-o>} {<nounset>})
    (C {<set>} {<-o>} {<pipefail>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:USER_ID)
          op: assign_op.Equal
          rhs: {(command_sub left_token:<Id.Left_DollarParen '$('> child:(C {<id>} {<-u>}))}
          spids: [66]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:GROUP_ID)
          op: assign_op.Equal
          rhs: {(command_sub left_token:<Id.Left_DollarParen '$('> child:(C {<id>} {<-g>}))}
          spids: [73]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:DOCKER_OPTS)
          op: assign_op.Equal
          rhs: 
            {
              (braced_var_sub
                token: <Id.VSub_Name DOCKER_OPTS>
                suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:{(DQ )})
              )
            }
          spids: [81]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:DOCKER)
          op: assign_op.Equal
          rhs: 
            {
              (sh_array_literal
                left: <Id.Op_LParen _>
                words: [{<docker>} {(${ Id.VSub_Name DOCKER_OPTS)}]
              )
            }
          spids: [89]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:DOCKER_HOST)
          op: assign_op.Equal
          rhs: 
            {
              (braced_var_sub
                token: <Id.VSub_Name DOCKER_HOST>
                suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:{(DQ )})
              )
            }
          spids: [98]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:DOCKER_MACHINE_NAME)
          op: assign_op.Equal
          rhs: 
            {
              (braced_var_sub
                token: <Id.VSub_Name DOCKER_MACHINE_NAME>
                suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:{(DQ <kube-dev>)})
              )
            }
          spids: [106]
        )
      ]
    )
    (C {<readonly>} 
      {<Id.Lit_VarLike 'DOCKER_MACHINE_DRIVER='> 
        (braced_var_sub
          token: <Id.VSub_Name DOCKER_MACHINE_DRIVER>
          suffix_op: 
            (suffix_op.Unary
              tok: <Id.VTest_ColonHyphen ':-'>
              arg_word: {(DQ <'virtualbox --virtualbox-cpu-count -1'>)}
            )
        )
      }
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:KUBE_ROOT)
          op: assign_op.Equal
          rhs: 
            {
              (command_sub
                left_token: <Id.Left_DollarParen '$('>
                child: 
                  (command.AndOr
                    ops: [Id.Op_DAmp]
                    children: [
                      (C {<cd>} 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: (C {<dirname>} {(DQ (${ Id.VSub_Name BASH_SOURCE))})
                          ) <'/..'>
                        }
                      )
                      (C {<pwd>} {<-P>})
                    ]
                  )
              )
            }
          spids: [130]
        )
      ]
    )
    (C {<source>} {(DQ (${ Id.VSub_Name KUBE_ROOT) <'/hack/lib/init.sh'>)})
    (C {<readonly>} {<Id.Lit_VarLike 'KUBE_BUILD_IMAGE_REPO='> <kube-build>})
    (C {<readonly>} 
      {<Id.Lit_VarLike 'KUBE_BUILD_IMAGE_CROSS_TAG='> 
        (DQ 
          (command_sub
            left_token: <Id.Left_DollarParen '$('>
            child: (C {<cat>} {(${ Id.VSub_Name KUBE_ROOT) <'/build/build-image/cross/VERSION'>})
          )
        )
      }
    )
    (C {<readonly>} 
      {<Id.Lit_VarLike 'KUBE_BUILD_IMAGE_VERSION_BASE='> 
        (DQ 
          (command_sub
            left_token: <Id.Left_DollarParen '$('>
            child: (C {<cat>} {(${ Id.VSub_Name KUBE_ROOT) <'/build/build-image/VERSION'>})
          )
        )
      }
    )
    (C {<readonly>} 
      {<Id.Lit_VarLike 'KUBE_BUILD_IMAGE_VERSION='> 
        (DQ (${ Id.VSub_Name KUBE_BUILD_IMAGE_VERSION_BASE) <-> 
          (${ Id.VSub_Name KUBE_BUILD_IMAGE_CROSS_TAG)
        )
      }
    )
    (C {<readonly>} 
      {<Id.Lit_VarLike 'LOCAL_OUTPUT_ROOT='> 
        (DQ (${ Id.VSub_Name KUBE_ROOT) <'/'> 
          (braced_var_sub
            token: <Id.VSub_Name OUT_DIR>
            suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:{<_output>})
          )
        )
      }
    )
    (C {<readonly>} 
      {<Id.Lit_VarLike 'LOCAL_OUTPUT_SUBPATH='> 
        (DQ (${ Id.VSub_Name LOCAL_OUTPUT_ROOT) <'/dockerized'>)
      }
    )
    (C {<readonly>} 
      {<Id.Lit_VarLike 'LOCAL_OUTPUT_BINPATH='> (DQ (${ Id.VSub_Name LOCAL_OUTPUT_SUBPATH) <'/bin'>)}
    )
    (C {<readonly>} 
      {<Id.Lit_VarLike 'LOCAL_OUTPUT_GOPATH='> (DQ (${ Id.VSub_Name LOCAL_OUTPUT_SUBPATH) <'/go'>)}
    )
    (C {<readonly>} 
      {<Id.Lit_VarLike 'LOCAL_OUTPUT_IMAGE_STAGING='> 
        (DQ (${ Id.VSub_Name LOCAL_OUTPUT_ROOT) <'/images'>)
      }
    )
    (C {<readonly>} 
      {<Id.Lit_VarLike 'THIS_PLATFORM_BIN='> (DQ (${ Id.VSub_Name LOCAL_OUTPUT_ROOT) <'/bin'>)}
    )
    (C {<readonly>} 
      {<Id.Lit_VarLike 'REMOTE_ROOT='> (DQ <'/go/src/'> (${ Id.VSub_Name KUBE_GO_PACKAGE))}
    )
    (C {<readonly>} 
      {<Id.Lit_VarLike 'REMOTE_OUTPUT_ROOT='> (DQ (${ Id.VSub_Name REMOTE_ROOT) <'/_output'>)}
    )
    (C {<readonly>} 
      {<Id.Lit_VarLike 'REMOTE_OUTPUT_SUBPATH='> 
        (DQ (${ Id.VSub_Name REMOTE_OUTPUT_ROOT) <'/dockerized'>)
      }
    )
    (C {<readonly>} 
      {<Id.Lit_VarLike 'REMOTE_OUTPUT_BINPATH='> (DQ (${ Id.VSub_Name REMOTE_OUTPUT_SUBPATH) <'/bin'>)}
    )
    (C {<readonly>} 
      {<Id.Lit_VarLike 'REMOTE_OUTPUT_GOPATH='> (DQ (${ Id.VSub_Name REMOTE_OUTPUT_SUBPATH) <'/go'>)}
    )
    (C {<readonly>} 
      {<Id.Lit_VarLike 'KUBE_RSYNC_PORT='> 
        (DQ 
          (braced_var_sub
            token: <Id.VSub_Name KUBE_RSYNC_PORT>
            suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:(word.Empty))
          )
        )
      }
    )
    (C {<readonly>} {<Id.Lit_VarLike 'KUBE_CONTAINER_RSYNC_PORT='> <8730>})
    (command.ShFunction
      name: 'kube::build::get_docker_wrapped_binaries'
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:debian_iptables_version)
                  op: assign_op.Equal
                  rhs: {<v8>}
                  spids: [440]
                )
              ]
            )
            (command.Case
              to_match: {($ Id.VSub_Number '$1')}
              arms: [
                (case_arm
                  pat_list: [{(DQ <amd64>)}]
                  action: [
                    (C {<local>} 
                      {<Id.Lit_VarLike 'targets='> 
                        (sh_array_literal
                          left: <Id.Op_LParen _>
                          words: [
                            {<cloud-controller-manager> <Id.Lit_Comma ','> <busybox>}
                            {<kube-apiserver> <Id.Lit_Comma ','> <busybox>}
                            {<kube-controller-manager> <Id.Lit_Comma ','> <busybox>}
                            {<kube-scheduler> <Id.Lit_Comma ','> <busybox>}
                            {<kube-aggregator> <Id.Lit_Comma ','> <busybox>}
                            {<kube-proxy> <Id.Lit_Comma ','> 
                              <'gcr.io/google-containers/debian-iptables-amd64'> <Id.Lit_Colon ':'> (${ Id.VSub_Name debian_iptables_version)
                            }
                          ]
                        )
                      }
                    )
                  ]
                  spids: [459 462 506 -1]
                )
                (case_arm
                  pat_list: [{(DQ <arm>)}]
                  action: [
                    (C {<local>} 
                      {<Id.Lit_VarLike 'targets='> 
                        (sh_array_literal
                          left: <Id.Op_LParen _>
                          words: [
                            {<cloud-controller-manager> <Id.Lit_Comma ','> <'arm32v7/busybox'>}
                            {<kube-apiserver> <Id.Lit_Comma ','> <'arm32v7/busybox'>}
                            {<kube-controller-manager> <Id.Lit_Comma ','> <'arm32v7/busybox'>}
                            {<kube-scheduler> <Id.Lit_Comma ','> <'arm32v7/busybox'>}
                            {<kube-aggregator> <Id.Lit_Comma ','> <'arm32v7/busybox'>}
                            {<kube-proxy> <Id.Lit_Comma ','> 
                              <'gcr.io/google-containers/debian-iptables-arm'> <Id.Lit_Colon ':'> (${ Id.VSub_Name debian_iptables_version)
                            }
                          ]
                        )
                      }
                    )
                  ]
                  spids: [509 512 556 -1]
                )
                (case_arm
                  pat_list: [{(DQ <arm64>)}]
                  action: [
                    (C {<local>} 
                      {<Id.Lit_VarLike 'targets='> 
                        (sh_array_literal
                          left: <Id.Op_LParen _>
                          words: [
                            {<cloud-controller-manager> <Id.Lit_Comma ','> <'arm64v8/busybox'>}
                            {<kube-apiserver> <Id.Lit_Comma ','> <'arm64v8/busybox'>}
                            {<kube-controller-manager> <Id.Lit_Comma ','> <'arm64v8/busybox'>}
                            {<kube-scheduler> <Id.Lit_Comma ','> <'arm64v8/busybox'>}
                            {<kube-aggregator> <Id.Lit_Comma ','> <'arm64v8/busybox'>}
                            {<kube-proxy> <Id.Lit_Comma ','> 
                              <'gcr.io/google-containers/debian-iptables-arm64'> <Id.Lit_Colon ':'> (${ Id.VSub_Name debian_iptables_version)
                            }
                          ]
                        )
                      }
                    )
                  ]
                  spids: [559 562 606 -1]
                )
                (case_arm
                  pat_list: [{(DQ <ppc64le>)}]
                  action: [
                    (C {<local>} 
                      {<Id.Lit_VarLike 'targets='> 
                        (sh_array_literal
                          left: <Id.Op_LParen _>
                          words: [
                            {<cloud-controller-manager> <Id.Lit_Comma ','> <'ppc64le/busybox'>}
                            {<kube-apiserver> <Id.Lit_Comma ','> <'ppc64le/busybox'>}
                            {<kube-controller-manager> <Id.Lit_Comma ','> <'ppc64le/busybox'>}
                            {<kube-scheduler> <Id.Lit_Comma ','> <'ppc64le/busybox'>}
                            {<kube-aggregator> <Id.Lit_Comma ','> <'ppc64le/busybox'>}
                            {<kube-proxy> <Id.Lit_Comma ','> 
                              <'gcr.io/google-containers/debian-iptables-ppc64le'> <Id.Lit_Colon ':'> (${ Id.VSub_Name debian_iptables_version)
                            }
                          ]
                        )
                      }
                    )
                  ]
                  spids: [609 612 656 -1]
                )
                (case_arm
                  pat_list: [{(DQ <s390x>)}]
                  action: [
                    (C {<local>} 
                      {<Id.Lit_VarLike 'targets='> 
                        (sh_array_literal
                          left: <Id.Op_LParen _>
                          words: [
                            {<cloud-controller-manager> <Id.Lit_Comma ','> <'s390x/busybox'>}
                            {<kube-apiserver> <Id.Lit_Comma ','> <'s390x/busybox'>}
                            {<kube-controller-manager> <Id.Lit_Comma ','> <'s390x/busybox'>}
                            {<kube-scheduler> <Id.Lit_Comma ','> <'s390x/busybox'>}
                            {<kube-aggregator> <Id.Lit_Comma ','> <'s390x/busybox'>}
                            {<kube-proxy> <Id.Lit_Comma ','> 
                              <'gcr.io/google-containers/debian-iptables-s390x'> <Id.Lit_Colon ':'> (${ Id.VSub_Name debian_iptables_version)
                            }
                          ]
                        )
                      }
                    )
                  ]
                  spids: [659 662 706 -1]
                )
              ]
            )
            (C {<echo>} 
              {
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name targets>
                    bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                  )
                )
              }
            )
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::verify_prereqs'
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<-r>} 
              {<Id.Lit_VarLike 'require_docker='> 
                (braced_var_sub
                  token: <Id.VSub_Number 1>
                  suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:{<true>})
                )
              }
            )
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                <status>
              } {(DQ <'Verifying Prerequisites....'>)}
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C 
                  {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> 
                    <Id.Lit_Colon ':'> <ensure_tar>
                  }
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<1>}
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C 
                  {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> 
                    <Id.Lit_Colon ':'> <ensure_rsync>
                  }
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<1>}
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (C {(${ Id.VSub_Name require_docker)})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C 
                          {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> 
                            <Id.Lit_Colon ':'> <ensure_docker_in_path>
                          }
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<1>}
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C 
                                      {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> 
                                        <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <is_osx>
                                      }
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C 
                                  {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> 
                                    <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <docker_available_on_osx>
                                  }
                                )
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Return return>
                                  arg_word: {<1>}
                                )
                              ]
                            )
                          ]
                          spids: [883 894]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C 
                          {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <util> <Id.Lit_Colon ':'> 
                            <Id.Lit_Colon ':'> <ensure_docker_daemon_connectivity>
                          }
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<1>}
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DParen
                                      child: 
                                        (arith_expr.Binary
                                          op_id: Id.Arith_Great
                                          left: {(${ Id.VSub_Name KUBE_VERBOSE)}
                                          right: {<Id.Lit_Digits 6>}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C 
                              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> 
                                <Id.Lit_Colon ':'> <status>
                              } {(DQ <'Docker Version:'>)}
                            )
                            (command.Pipeline
                              children: [
                                (C 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name DOCKER>
                                        bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                      )
                                    )
                                  } {<version>}
                                )
                                (C 
                                  {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> 
                                    <Id.Lit_Colon ':'> <info_from_stdin>
                                  }
                                )
                              ]
                              negated: F
                            )
                          ]
                          spids: [931 947]
                        )
                      ]
                    )
                  ]
                  spids: [858 865]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:KUBE_GIT_BRANCH)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.AndOr
                            ops: [Id.Op_DPipe]
                            children: [
                              (command.Simple
                                words: [{<git>} {<symbolic-ref>} {<--short>} {<-q>} {<HEAD>}]
                                redirects: [
                                  (redir
                                    op: <Id.Redir_Great '2>'>
                                    loc: (redir_loc.Fd fd:2)
                                    arg: {<'/dev/null'>}
                                  )
                                ]
                                do_fork: T
                              )
                              (C {<true>})
                            ]
                          )
                      )
                    }
                  spids: [992]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:KUBE_ROOT_HASH)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (C 
                            {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> 
                              <Id.Lit_Colon ':'> <short_hash>
                            } 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name HOSTNAME>
                                  suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:(word.Empty))
                                ) <':'> (${ Id.VSub_Name KUBE_ROOT) <':'> (${ Id.VSub_Name KUBE_GIT_BRANCH)
                              )
                            }
                          )
                      )
                    }
                  spids: [1013]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:KUBE_BUILD_IMAGE_TAG_BASE)
                  op: assign_op.Equal
                  rhs: {(DQ <build-> (${ Id.VSub_Name KUBE_ROOT_HASH))}
                  spids: [1040]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:KUBE_BUILD_IMAGE_TAG)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ (${ Id.VSub_Name KUBE_BUILD_IMAGE_TAG_BASE) <-> 
                        (${ Id.VSub_Name KUBE_BUILD_IMAGE_VERSION)
                      )
                    }
                  spids: [1049]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:KUBE_BUILD_IMAGE)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ (${ Id.VSub_Name KUBE_BUILD_IMAGE_REPO) <':'> 
                        (${ Id.VSub_Name KUBE_BUILD_IMAGE_TAG)
                      )
                    }
                  spids: [1061]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:KUBE_BUILD_CONTAINER_NAME_BASE)
                  op: assign_op.Equal
                  rhs: {(DQ <kube-build-> (${ Id.VSub_Name KUBE_ROOT_HASH))}
                  spids: [1073]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:KUBE_BUILD_CONTAINER_NAME)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ (${ Id.VSub_Name KUBE_BUILD_CONTAINER_NAME_BASE) <-> 
                        (${ Id.VSub_Name KUBE_BUILD_IMAGE_VERSION)
                      )
                    }
                  spids: [1082]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:KUBE_RSYNC_CONTAINER_NAME_BASE)
                  op: assign_op.Equal
                  rhs: {(DQ <kube-rsync-> (${ Id.VSub_Name KUBE_ROOT_HASH))}
                  spids: [1094]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:KUBE_RSYNC_CONTAINER_NAME)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ (${ Id.VSub_Name KUBE_RSYNC_CONTAINER_NAME_BASE) <-> 
                        (${ Id.VSub_Name KUBE_BUILD_IMAGE_VERSION)
                      )
                    }
                  spids: [1103]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:KUBE_DATA_CONTAINER_NAME_BASE)
                  op: assign_op.Equal
                  rhs: {(DQ <kube-build-data-> (${ Id.VSub_Name KUBE_ROOT_HASH))}
                  spids: [1115]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:KUBE_DATA_CONTAINER_NAME)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ (${ Id.VSub_Name KUBE_DATA_CONTAINER_NAME_BASE) <-> 
                        (${ Id.VSub_Name KUBE_BUILD_IMAGE_VERSION)
                      )
                    }
                  spids: [1124]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:DOCKER_MOUNT_ARGS)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (sh_array_literal
                        left: <Id.Op_LParen _>
                        words: [{<--volumes-from>} {(DQ (${ Id.VSub_Name KUBE_DATA_CONTAINER_NAME))}]
                      )
                    }
                  spids: [1136]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:LOCAL_OUTPUT_BUILD_CONTEXT)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ (${ Id.VSub_Name LOCAL_OUTPUT_IMAGE_STAGING) <'/'> 
                        (${ Id.VSub_Name KUBE_BUILD_IMAGE)
                      )
                    }
                  spids: [1148]
                )
              ]
            )
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <version> <Id.Lit_Colon ':'> 
                <Id.Lit_Colon ':'> <get_version_vars>
              }
            )
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <version> <Id.Lit_Colon ':'> 
                <Id.Lit_Colon ':'> <save_version_vars>
              } {(DQ (${ Id.VSub_Name KUBE_ROOT) <'/.dockerized-kube-version-defs'>)}
            )
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::docker_available_on_osx'
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_z
                                  child: {(DQ (${ Id.VSub_Name DOCKER_HOST))}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_S
                                          child: {(DQ <'/var/run/docker.sock'>)}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C 
                              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> 
                                <Id.Lit_Colon ':'> <status>
                              } {(DQ <'Using Docker for MacOS'>)}
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                              arg_word: {<0>}
                            )
                          ]
                          spids: [1228 1241]
                        )
                      ]
                    )
                    (C 
                      {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> 
                        <Id.Lit_Colon ':'> <status>
                      } {(DQ <'No docker host is set. Checking options for setting one...'>)}
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_z
                                          child: 
                                            {
                                              (DQ 
                                                (command_sub
                                                  left_token: <Id.Left_DollarParen '$('>
                                                  child: (C {<which>} {<docker-machine>})
                                                )
                                              )
                                            }
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C 
                              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> 
                                <Id.Lit_Colon ':'> <status>
                              } 
                              {
                                (DQ 
                                  <
'It looks like you\'re running Mac OS X, yet neither Docker for Mac nor docker-machine can be found.'
                                  >
                                )
                              }
                            )
                            (C 
                              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> 
                                <Id.Lit_Colon ':'> <status>
                              } {(DQ <'See: https://docs.docker.com/engine/installation/mac/ for installation instructions.'>)}
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                              arg_word: {<1>}
                            )
                          ]
                          spids: [1279 1296]
                        )
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_n
                                          child: 
                                            {
                                              (DQ 
                                                (command_sub
                                                  left_token: <Id.Left_DollarParen '$('>
                                                  child: (C {<which>} {<docker-machine>})
                                                )
                                              )
                                            }
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C 
                              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> 
                                <Id.Lit_Colon ':'> <prepare_docker_machine>
                              }
                            )
                          ]
                          spids: [1330 1347]
                        )
                      ]
                    )
                  ]
                  spids: [1210 1225]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::prepare_docker_machine'
      body: 
        (BraceGroup
          children: [
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                <status>
              } {(DQ <'docker-machine was found.'>)}
            )
            (C {<local>} 
              {<Id.Lit_VarLike 'available_memory_bytes='> 
                (command_sub
                  left_token: <Id.Left_DollarParen '$('>
                  child: 
                    (command.Simple
                      words: [{<sysctl>} {<-n>} {<hw.memsize>}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '2>'>
                          loc: (redir_loc.Fd fd:2)
                          arg: {<'/dev/null'>}
                        )
                      ]
                      do_fork: T
                    )
                )
              }
            )
            (C {<local>} {<Id.Lit_VarLike 'bytes_in_mb='> <1048576>})
            (C {<local>} {<Id.Lit_VarLike 'memory_divisor='> <2>})
            (C {<local>} 
              {<Id.Lit_VarLike 'virtualbox_memory_mb='> 
                (word_part.ArithSub
                  anode: 
                    (arith_expr.Binary
                      op_id: Id.Arith_Slash
                      left: {(${ Id.VSub_Name available_memory_bytes)}
                      right: 
                        (arith_expr.Binary
                          op_id: Id.Arith_Star
                          left: {(${ Id.VSub_Name bytes_in_mb)}
                          right: {(${ Id.VSub_Name memory_divisor)}
                        )
                    )
                )
              }
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.Simple
                  words: [{<docker-machine>} {<inspect>} {(DQ (${ Id.VSub_Name DOCKER_MACHINE_NAME))}]
                  redirects: [
                    (redir
                      op: <Id.Redir_AndGreat '&>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {<'/dev/null'>}
                    )
                  ]
                  do_fork: T
                )
                (BraceGroup
                  children: [
                    (C 
                      {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> 
                        <Id.Lit_Colon ':'> <status>
                      } {(DQ <'Creating a machine to build Kubernetes'>)}
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (command.Simple
                          words: [
                            {<docker-machine>}
                            {<create>}
                            {<--driver>}
                            {(${ Id.VSub_Name DOCKER_MACHINE_DRIVER)}
                            {<--virtualbox-memory>}
                            {(DQ (${ Id.VSub_Name virtualbox_memory_mb))}
                            {<--engine-env>}
                            {<Id.Lit_VarLike 'HTTP_PROXY='> 
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name KUBERNETES_HTTP_PROXY>
                                  suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:(word.Empty))
                                )
                              )
                            }
                            {<--engine-env>}
                            {<Id.Lit_VarLike 'HTTPS_PROXY='> 
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name KUBERNETES_HTTPS_PROXY>
                                  suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:(word.Empty))
                                )
                              )
                            }
                            {<--engine-env>}
                            {<Id.Lit_VarLike 'NO_PROXY='> 
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name KUBERNETES_NO_PROXY>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      tok: <Id.VTest_ColonHyphen ':-'>
                                      arg_word: {<127.0.0.1>}
                                    )
                                )
                              )
                            }
                            {(DQ (${ Id.VSub_Name DOCKER_MACHINE_NAME))}
                          ]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<'/dev/null'>}
                            )
                          ]
                          do_fork: T
                        )
                        (BraceGroup
                          children: [
                            (C 
                              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> 
                                <Id.Lit_Colon ':'> <error>
                              } {(DQ <'Something went wrong creating a machine.'>)}
                            )
                            (C 
                              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> 
                                <Id.Lit_Colon ':'> <error>
                              } {(DQ <'Try the following: '>)}
                            )
                            (C 
                              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> 
                                <Id.Lit_Colon ':'> <error>
                              } 
                              {
                                (DQ <'docker-machine create -d '> 
                                  (${ Id.VSub_Name DOCKER_MACHINE_DRIVER) <' --virtualbox-memory '> (${ Id.VSub_Name virtualbox_memory_mb) <' '> 
                                  (${ Id.VSub_Name DOCKER_MACHINE_NAME)
                                )
                              }
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                              arg_word: {<1>}
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.Simple
              words: [{<docker-machine>} {<start>} {(DQ (${ Id.VSub_Name DOCKER_MACHINE_NAME))}]
              redirects: [
                (redir
                  op: <Id.Redir_AndGreat '&>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {<'/dev/null'>}
                )
              ]
              do_fork: T
            )
            (C {<local>} {<docker_machine_out>})
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (command.Pipeline
                          children: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:docker_machine_out)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (command.Simple
                                            words: [
                                              {<docker-machine>}
                                              {<env>}
                                              {(DQ (${ Id.VSub_Name DOCKER_MACHINE_NAME))}
                                            ]
                                            redirects: [
                                              (redir
                                                op: <Id.Redir_GreatAnd '2>&'>
                                                loc: (redir_loc.Fd fd:2)
                                                arg: {<1>}
                                              )
                                            ]
                                            do_fork: T
                                          )
                                      )
                                    }
                                  spids: [1657]
                                )
                              ]
                            )
                          ]
                          negated: T
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_EqualTilde
                                          left: {(${ Id.VSub_Name docker_machine_out)}
                                          right: {(DQ <'Error checking TLS connection'>)}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<echo>} {(${ Id.VSub_Name docker_machine_out)})
                            (C {<docker-machine>} {<regenerate-certs>} 
                              {(${ Id.VSub_Name DOCKER_MACHINE_NAME)}
                            )
                          ]
                          spids: [1677 1694]
                        )
                      ]
                      else_action: [(C {<sleep>} {<1>})]
                    )
                  ]
                )
            )
            (C {<eval>} 
              {
                (command_sub
                  left_token: <Id.Left_DollarParen '$('>
                  child: (C {<docker-machine>} {<env>} {(DQ (${ Id.VSub_Name DOCKER_MACHINE_NAME))})
                )
              }
            )
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                <status>
              } 
              {
                (DQ <'A Docker host using docker-machine named \''> 
                  (${ Id.VSub_Name DOCKER_MACHINE_NAME) <'\' is ready to go!'>
                )
              }
            )
            (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<0>})
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::is_osx'
      body: 
        (BraceGroup
          children: [
            (command.DBracket
              expr: 
                (bool_expr.Binary
                  op_id: Id.BoolBinary_GlobDEqual
                  left: {(DQ (command_sub left_token:<Id.Left_DollarParen '$('> child:(C {<uname>})))}
                  right: {(DQ <Darwin>)}
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::is_gnu_sed'
      body: 
        (BraceGroup
          children: [
            (command.DBracket
              expr: 
                (bool_expr.Binary
                  op_id: Id.BoolBinary_GlobDEqual
                  left: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.Simple
                            words: [{<sed>} {<--version>}]
                            redirects: [
                              (redir
                                op: <Id.Redir_GreatAnd '2>&'>
                                loc: (redir_loc.Fd fd:2)
                                arg: {<1>}
                              )
                            ]
                            do_fork: T
                          )
                      )
                    }
                  right: {<Id.Lit_Other '*'> <GNU> <Id.Lit_Other '*'>}
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::ensure_rsync'
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_z
                                  child: 
                                    {
                                      (DQ 
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: (C {<which>} {<rsync>})
                                        )
                                      )
                                    }
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C 
                      {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> 
                        <Id.Lit_Colon ':'> <error>
                      } {(DQ <'Can\'t find \'rsync\' in PATH, please fix and retry.'>)}
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<1>}
                    )
                  ]
                  spids: [1852 1869]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::update_dockerfile'
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C 
                              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> 
                                <Id.Lit_Colon ':'> <is_gnu_sed>
                              }
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:sed_opts)
                          op: assign_op.Equal
                          rhs: {(sh_array_literal left:<Id.Op_LParen _> words:[{<-i>}])}
                          spids: [1924]
                        )
                      ]
                    )
                  ]
                  spids: [1910 1921]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:sed_opts)
                      op: assign_op.Equal
                      rhs: {(sh_array_literal left:<Id.Op_LParen _> words:[{<-i>} {(SQ )}])}
                      spids: [1933]
                    )
                  ]
                )
              ]
            )
            (C {<sed>} 
              {
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name sed_opts>
                    bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                  )
                )
              } {(DQ <'s/KUBE_BUILD_IMAGE_CROSS_TAG/'> (${ Id.VSub_Name KUBE_BUILD_IMAGE_CROSS_TAG) <'/'>)} 
              {(DQ (${ Id.VSub_Name LOCAL_OUTPUT_BUILD_CONTEXT) <'/Dockerfile'>)}
            )
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::set_proxy'
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_n
                                  child: 
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          token: <Id.VSub_Name KUBERNETES_HTTPS_PROXY>
                                          suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:(word.Empty))
                                        )
                                      )
                                    }
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.Simple
                      words: [
                        {<echo>}
                        {(DQ <'ENV https_proxy '> ($ Id.VSub_DollarName '$KUBERNETES_HTTPS_PROXY'))}
                      ]
                      redirects: [
                        (redir
                          op: <Id.Redir_DGreat '>>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ (${ Id.VSub_Name LOCAL_OUTPUT_BUILD_CONTEXT) <'/Dockerfile'>)}
                        )
                      ]
                      do_fork: T
                    )
                  ]
                  spids: [1989 2005]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_n
                                  child: 
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          token: <Id.VSub_Name KUBERNETES_HTTP_PROXY>
                                          suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:(word.Empty))
                                        )
                                      )
                                    }
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.Simple
                      words: [
                        {<echo>}
                        {(DQ <'ENV http_proxy '> ($ Id.VSub_DollarName '$KUBERNETES_HTTP_PROXY'))}
                      ]
                      redirects: [
                        (redir
                          op: <Id.Redir_DGreat '>>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ (${ Id.VSub_Name LOCAL_OUTPUT_BUILD_CONTEXT) <'/Dockerfile'>)}
                        )
                      ]
                      do_fork: T
                    )
                  ]
                  spids: [2028 2044]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_n
                                  child: 
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          token: <Id.VSub_Name KUBERNETES_NO_PROXY>
                                          suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:(word.Empty))
                                        )
                                      )
                                    }
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.Simple
                      words: [
                        {<echo>}
                        {(DQ <'ENV no_proxy '> ($ Id.VSub_DollarName '$KUBERNETES_NO_PROXY'))}
                      ]
                      redirects: [
                        (redir
                          op: <Id.Redir_DGreat '>>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ (${ Id.VSub_Name LOCAL_OUTPUT_BUILD_CONTEXT) <'/Dockerfile'>)}
                        )
                      ]
                      do_fork: T
                    )
                  ]
                  spids: [2067 2083]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::ensure_docker_in_path'
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_z
                                  child: 
                                    {
                                      (DQ 
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: (C {<which>} {<docker>})
                                        )
                                      )
                                    }
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C 
                      {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> 
                        <Id.Lit_Colon ':'> <error>
                      } {(DQ <'Can\'t find \'docker\' in PATH, please fix and retry.'>)}
                    )
                    (C 
                      {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> 
                        <Id.Lit_Colon ':'> <error>
                      } {(DQ <'See https://docs.docker.com/installation/#installation for installation instructions.'>)}
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<1>}
                    )
                  ]
                  spids: [2123 2140]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::ensure_tar'
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_n
                                  child: 
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          token: <Id.VSub_Name TAR>
                                          suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:(word.Empty))
                                        )
                                      )
                                    }
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(command.ControlFlow token:<Id.ControlFlow_Return return>)]
                  spids: [2194 2210]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:TAR)
                  op: assign_op.Equal
                  rhs: {<tar>}
                  spids: [2224]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.Simple
                              words: [{<which>} {<gtar>}]
                              redirects: [
                                (redir
                                  op: <Id.Redir_AndGreat '&>'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {<'/dev/null'>}
                                )
                              ]
                              do_fork: T
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:TAR)
                          op: assign_op.Equal
                          rhs: {<gtar>}
                          spids: [2241]
                        )
                      ]
                    )
                  ]
                  spids: [2228 2238]
                )
              ]
              else_action: [
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (command.Simple
                                  words: [{<which>} {<gnutar>}]
                                  redirects: [
                                    (redir
                                      op: <Id.Redir_AndGreat '&>'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {<'/dev/null'>}
                                    )
                                  ]
                                  do_fork: T
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:TAR)
                              op: assign_op.Equal
                              rhs: {<gnutar>}
                              spids: [2261]
                            )
                          ]
                        )
                      ]
                      spids: [2248 2258]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.Pipeline
                              children: [
                                (C {(DQ (${ Id.VSub_Name TAR))} {<--version>})
                                (C {<grep>} {<-q>} {<GNU>})
                              ]
                              negated: T
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<echo>} {(DQ <'  !!! Cannot find GNU tar. Build on Linux or install GNU tar'>)})
                    (C {<echo>} {(DQ <'      on Mac OS X (brew install gnu-tar).'>)})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<1>}
                    )
                  ]
                  spids: [2271 2292]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::has_docker'
      body: 
        (BraceGroup
          children: [
            (command.Simple
              words: [{<which>} {<docker>}]
              redirects: [
                (redir
                  op: <Id.Redir_AndGreat '&>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {<'/dev/null'>}
                )
              ]
              do_fork: T
            )
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::has_ip'
      body: 
        (BraceGroup
          children: [
            (command.Pipeline
              children: [
                (C {<ip>} {<-Version>})
                (command.Simple
                  words: [{<grep>} {(SQ <iproute2>)}]
                  redirects: [
                    (redir
                      op: <Id.Redir_AndGreat '&>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {<'/dev/null'>}
                    )
                  ]
                  do_fork: T
                )
              ]
              negated: F
            )
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::docker_image_exists'
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.LogicalAnd
                      left: (bool_expr.Unary op_id:Id.BoolUnary_n child:{($ Id.VSub_Number '$1')})
                      right: (bool_expr.Unary op_id:Id.BoolUnary_n child:{($ Id.VSub_Number '$2')})
                    )
                )
                (BraceGroup
                  children: [
                    (C 
                      {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> 
                        <Id.Lit_Colon ':'> <error>
                      } {(DQ <'Internal error. Image not specified in docker_image_exists.'>)}
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Exit exit>
                      arg_word: {<2>}
                    )
                  ]
                )
              ]
            )
            (command.DBracket
              expr: 
                (bool_expr.WordTest
                  w: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (C 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name DOCKER>
                                  bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                )
                              )
                            } {<images>} {<-q>} {(DQ (${ Id.VSub_Number 1) <':'> (${ Id.VSub_Number 2))}
                          )
                      )
                    }
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::docker_delete_old_images'
      body: 
        (BraceGroup
          children: [
            (command.ForEach
              iter_name: tag
              iter_words: [
                {
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: 
                      (command.Pipeline
                        children: [
                          (C 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name DOCKER>
                                  bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                )
                              )
                            } {<images>} {(${ Id.VSub_Number 1)}
                          )
                          (C {<tail>} {<-n>} {<Id.Lit_Other '+'> <2>})
                          (C {<awk>} {(SQ <'{print $2}'>)})
                        ]
                        negated: F
                      )
                  )
                }
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobNEqual
                                          left: {(DQ (${ Id.VSub_Name tag))}
                                          right: {(DQ (${ Id.VSub_Number 2)) <Id.Lit_Other '*'>}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.Simple
                              words: [
                                {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> 
                                  <Id.Lit_Colon ':'> <status>
                                }
                                {
                                  (DQ <'Keeping image '> (${ Id.VSub_Number 1) <':'> 
                                    (${ Id.VSub_Name tag)
                                  )
                                }
                              ]
                              more_env: [(env_pair name:V val:{<3>} spids:[2588])]
                              do_fork: T
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Continue continue>
                            )
                          ]
                          spids: [2562 2585]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.LogicalOr
                                          left: 
                                            (bool_expr.Unary
                                              op_id: Id.BoolUnary_z
                                              child: 
                                                {
                                                  (DQ 
                                                    (braced_var_sub
                                                      token: <Id.VSub_Number 3>
                                                      suffix_op: 
                                                        (suffix_op.Unary
                                                          tok: <Id.VTest_ColonHyphen ':-'>
                                                          arg_word: (word.Empty)
                                                        )
                                                    )
                                                  )
                                                }
                                            )
                                          right: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobNEqual
                                              left: {(DQ (${ Id.VSub_Name tag))}
                                              right: {(DQ (${ Id.VSub_Number 3))}
                                            )
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.Simple
                              words: [
                                {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> 
                                  <Id.Lit_Colon ':'> <status>
                                }
                                {
                                  (DQ <'Deleting image '> (${ Id.VSub_Number 1) <':'> 
                                    (${ Id.VSub_Name tag)
                                  )
                                }
                              ]
                              more_env: [(env_pair name:V val:{<2>} spids:[2654])]
                              do_fork: T
                            )
                            (command.Simple
                              words: [
                                {
                                  (DQ 
                                    (braced_var_sub
                                      token: <Id.VSub_Name DOCKER>
                                      bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                    )
                                  )
                                }
                                {<rmi>}
                                {(DQ (${ Id.VSub_Number 1) <':'> (${ Id.VSub_Name tag))}
                              ]
                              redirects: [
                                (redir
                                  op: <Id.Redir_Great '>'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {<'/dev/null'>}
                                )
                              ]
                              do_fork: T
                            )
                          ]
                          spids: [2618 2651]
                        )
                      ]
                      else_action: [
                        (command.Simple
                          words: [
                            {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> 
                              <Id.Lit_Colon ':'> <status>
                            }
                            {
                              (DQ <'Keeping image '> (${ Id.VSub_Number 1) <':'> (${ Id.VSub_Name tag))
                            }
                          ]
                          more_env: [(env_pair name:V val:{<3>} spids:[2705])]
                          do_fork: T
                        )
                      ]
                    )
                  ]
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::docker_delete_old_containers'
      body: 
        (BraceGroup
          children: [
            (command.ForEach
              iter_name: container
              iter_words: [
                {
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: 
                      (command.Pipeline
                        children: [
                          (C 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name DOCKER>
                                  bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                )
                              )
                            } {<ps>} {<-a>}
                          )
                          (C {<tail>} {<-n>} {<Id.Lit_Other '+'> <2>})
                          (C {<awk>} {(SQ <'{print $NF}'>)})
                        ]
                        negated: F
                      )
                  )
                }
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobNEqual
                                          left: {(DQ (${ Id.VSub_Name container))}
                                          right: {(DQ (${ Id.VSub_Number 1)) <Id.Lit_Other '*'>}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.Simple
                              words: [
                                {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> 
                                  <Id.Lit_Colon ':'> <status>
                                }
                                {(DQ <'Keeping container '> (${ Id.VSub_Name container))}
                              ]
                              more_env: [(env_pair name:V val:{<3>} spids:[2840])]
                              do_fork: T
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Continue continue>
                            )
                          ]
                          spids: [2814 2837]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.LogicalOr
                                          left: 
                                            (bool_expr.Unary
                                              op_id: Id.BoolUnary_z
                                              child: 
                                                {
                                                  (DQ 
                                                    (braced_var_sub
                                                      token: <Id.VSub_Number 2>
                                                      suffix_op: 
                                                        (suffix_op.Unary
                                                          tok: <Id.VTest_ColonHyphen ':-'>
                                                          arg_word: (word.Empty)
                                                        )
                                                    )
                                                  )
                                                }
                                            )
                                          right: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobNEqual
                                              left: {(DQ (${ Id.VSub_Name container))}
                                              right: {(DQ (${ Id.VSub_Number 2))}
                                            )
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.Simple
                              words: [
                                {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> 
                                  <Id.Lit_Colon ':'> <status>
                                }
                                {(DQ <'Deleting container '> (${ Id.VSub_Name container))}
                              ]
                              more_env: [(env_pair name:V val:{<2>} spids:[2901])]
                              do_fork: T
                            )
                            (C 
                              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> 
                                <Id.Lit_Colon ':'> <destroy_container>
                              } {(DQ (${ Id.VSub_Name container))}
                            )
                          ]
                          spids: [2865 2898]
                        )
                      ]
                      else_action: [
                        (command.Simple
                          words: [
                            {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> 
                              <Id.Lit_Colon ':'> <status>
                            }
                            {(DQ <'Keeping container '> (${ Id.VSub_Name container))}
                          ]
                          more_env: [(env_pair name:V val:{<3>} spids:[2938])]
                          do_fork: T
                        )
                      ]
                    )
                  ]
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::short_hash'
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Binary
                      op_id: Id.BoolBinary_eq
                      left: {($ Id.VSub_Pound '$#')}
                      right: {<1>}
                    )
                )
                (BraceGroup
                  children: [
                    (C 
                      {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> 
                        <Id.Lit_Colon ':'> <error>
                      } {(DQ <'Internal error.  No data based to short_hash.'>)}
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Exit exit>
                      arg_word: {<2>}
                    )
                  ]
                )
              ]
            )
            (C {<local>} {<short_hash>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.Simple
                              words: [{<which>} {<md5>}]
                              redirects: [
                                (redir
                                  op: <Id.Redir_Great '>'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {<'/dev/null'>}
                                )
                                (redir
                                  op: <Id.Redir_GreatAnd '2>&'>
                                  loc: (redir_loc.Fd fd:2)
                                  arg: {<1>}
                                )
                              ]
                              do_fork: T
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:short_hash)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<md5>} {<-q>} {<-s>} {(DQ ($ Id.VSub_Number '$1'))})
                              )
                            }
                          spids: [3041]
                        )
                      ]
                    )
                  ]
                  spids: [3025 3038]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:short_hash)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (command.Pipeline
                                children: [
                                  (C {<echo>} {<-n>} {(DQ ($ Id.VSub_Number '$1'))})
                                  (C {<md5sum>})
                                ]
                                negated: F
                              )
                          )
                        }
                      spids: [3058]
                    )
                  ]
                )
              ]
            )
            (C {<echo>} 
              {
                (braced_var_sub
                  token: <Id.VSub_Name short_hash>
                  suffix_op: (suffix_op.Slice begin:{<Id.Lit_Digits 0>} length:{<Id.Lit_Digits 10>})
                )
              }
            )
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::destroy_container'
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.Simple
                  words: [
                    {
                      (DQ 
                        (braced_var_sub
                          token: <Id.VSub_Name DOCKER>
                          bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                        )
                      )
                    }
                    {<kill>}
                    {(DQ ($ Id.VSub_Number '$1'))}
                  ]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {<'/dev/null'>}
                    )
                    (redir
                      op: <Id.Redir_GreatAnd '2>&'>
                      loc: (redir_loc.Fd fd:2)
                      arg: {<1>}
                    )
                  ]
                  do_fork: T
                )
                (C {<true>})
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobEqual
                                  left: 
                                    {
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C 
                                            {
                                              (DQ 
                                                (braced_var_sub
                                                  token: <Id.VSub_Name DOCKER>
                                                  bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                                )
                                              )
                                            } {<version>} {<--format>} {(SQ <'{{.Server.Version}}'>)}
                                          )
                                      )
                                    }
                                  right: {<17.06.0> <Id.Lit_Other '*'>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (command.Simple
                          words: [
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name DOCKER>
                                  bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                )
                              )
                            }
                            {<wait>}
                            {(DQ ($ Id.VSub_Number '$1'))}
                          ]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<'/dev/null'>}
                            )
                            (redir
                              op: <Id.Redir_GreatAnd '2>&'>
                              loc: (redir_loc.Fd fd:2)
                              arg: {<1>}
                            )
                          ]
                          more_env: [(env_pair name:DOCKER_API_VERSION val:{<v1.29>} spids:[3185])]
                          do_fork: T
                        )
                        (C {<true>})
                      ]
                    )
                  ]
                  spids: [3143 3174]
                )
              ]
              else_action: [
                (command.AndOr
                  ops: [Id.Op_DPipe]
                  children: [
                    (command.Simple
                      words: [
                        {
                          (DQ 
                            (braced_var_sub
                              token: <Id.VSub_Name DOCKER>
                              bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                            )
                          )
                        }
                        {<wait>}
                        {(DQ ($ Id.VSub_Number '$1'))}
                      ]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {<'/dev/null'>}
                        )
                        (redir
                          op: <Id.Redir_GreatAnd '2>&'>
                          loc: (redir_loc.Fd fd:2)
                          arg: {<1>}
                        )
                      ]
                      do_fork: T
                    )
                    (C {<true>})
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.Simple
                  words: [
                    {
                      (DQ 
                        (braced_var_sub
                          token: <Id.VSub_Name DOCKER>
                          bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                        )
                      )
                    }
                    {<rm>}
                    {<-f>}
                    {<-v>}
                    {(DQ ($ Id.VSub_Number '$1'))}
                  ]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {<'/dev/null'>}
                    )
                    (redir
                      op: <Id.Redir_GreatAnd '2>&'>
                      loc: (redir_loc.Fd fd:2)
                      arg: {<1>}
                    )
                  ]
                  do_fork: T
                )
                (C {<true>})
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::clean'
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C 
                              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> 
                                <Id.Lit_Colon ':'> <has_docker>
                              }
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C 
                      {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> 
                        <Id.Lit_Colon ':'> <docker_delete_old_containers>
                      } {(DQ (${ Id.VSub_Name KUBE_BUILD_CONTAINER_NAME_BASE))}
                    )
                    (C 
                      {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> 
                        <Id.Lit_Colon ':'> <docker_delete_old_containers>
                      } {(DQ (${ Id.VSub_Name KUBE_RSYNC_CONTAINER_NAME_BASE))}
                    )
                    (C 
                      {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> 
                        <Id.Lit_Colon ':'> <docker_delete_old_containers>
                      } {(DQ (${ Id.VSub_Name KUBE_DATA_CONTAINER_NAME_BASE))}
                    )
                    (C 
                      {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> 
                        <Id.Lit_Colon ':'> <docker_delete_old_images>
                      } {(DQ (${ Id.VSub_Name KUBE_BUILD_IMAGE_REPO))} {(DQ (${ Id.VSub_Name KUBE_BUILD_IMAGE_TAG_BASE))}
                    )
                    (command.Simple
                      words: [
                        {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> 
                          <Id.Lit_Colon ':'> <status>
                        }
                        {(DQ <'Cleaning all untagged docker images'>)}
                      ]
                      more_env: [(env_pair name:V val:{<2>} spids:[3383])]
                      do_fork: T
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (command.Simple
                          words: [
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name DOCKER>
                                  bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                )
                              )
                            }
                            {<rmi>}
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C 
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          token: <Id.VSub_Name DOCKER>
                                          bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                        )
                                      )
                                    } {<images>} {<-q>} {<--filter>} {(SQ <'dangling=true'>)}
                                  )
                              )
                            }
                          ]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '2>'>
                              loc: (redir_loc.Fd fd:2)
                              arg: {<'/dev/null'>}
                            )
                          ]
                          do_fork: T
                        )
                        (C {<true>})
                      ]
                    )
                  ]
                  spids: [3301 3313]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_d
                                  child: {(DQ (${ Id.VSub_Name LOCAL_OUTPUT_ROOT))}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C 
                      {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> 
                        <Id.Lit_Colon ':'> <status>
                      } {(DQ <'Removing _output directory'>)}
                    )
                    (C {<rm>} {<-rf>} {(DQ (${ Id.VSub_Name LOCAL_OUTPUT_ROOT))})
                  ]
                  spids: [3444 3459]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::build_image'
      body: 
        (BraceGroup
          children: [
            (C {<mkdir>} {<-p>} {(DQ (${ Id.VSub_Name LOCAL_OUTPUT_BUILD_CONTEXT))})
            (C {<chown>} {<-R>} 
              {(${ Id.VSub_Name USER_ID) <Id.Lit_Colon ':'> (${ Id.VSub_Name GROUP_ID)} {(DQ (${ Id.VSub_Name LOCAL_OUTPUT_BUILD_CONTEXT))}
            )
            (C {<cp>} {<'/etc/localtime'>} {(DQ (${ Id.VSub_Name LOCAL_OUTPUT_BUILD_CONTEXT) <'/'>)})
            (C {<cp>} {<'build/build-image/Dockerfile'>} 
              {(DQ (${ Id.VSub_Name LOCAL_OUTPUT_BUILD_CONTEXT) <'/Dockerfile'>)}
            )
            (C {<cp>} {<'build/build-image/rsyncd.sh'>} 
              {(DQ (${ Id.VSub_Name LOCAL_OUTPUT_BUILD_CONTEXT) <'/'>)}
            )
            (command.Pipeline
              children: [
                (command.Simple
                  words: [
                    {<dd>}
                    {<Id.Lit_VarLike 'if='> <'/dev/urandom'>}
                    {<Id.Lit_VarLike 'bs='> <512>}
                    {<Id.Lit_VarLike 'count='> <1>}
                  ]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '2>'>
                      loc: (redir_loc.Fd fd:2)
                      arg: {<'/dev/null'>}
                    )
                  ]
                  do_fork: T
                )
                (command.Simple
                  words: [{<tr>} {<-dc>} {(SQ <A-Za-z0-9>)}]
                  more_env: [(env_pair name:LC_ALL val:{<C>} spids:[3597])]
                  do_fork: T
                )
                (command.Simple
                  words: [{<dd>} {<Id.Lit_VarLike 'bs='> <32>} {<Id.Lit_VarLike 'count='> <1>}]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '2>'>
                      loc: (redir_loc.Fd fd:2)
                      arg: {<'/dev/null'>}
                    )
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ (${ Id.VSub_Name LOCAL_OUTPUT_BUILD_CONTEXT) <'/rsyncd.password'>)}
                    )
                  ]
                  do_fork: T
                )
              ]
              negated: F
            )
            (C {<chmod>} {<Id.Lit_VarLike 'go='>} 
              {(DQ (${ Id.VSub_Name LOCAL_OUTPUT_BUILD_CONTEXT) <'/rsyncd.password'>)}
            )
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                <update_dockerfile>
              }
            )
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                <set_proxy>
              }
            )
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                <docker_build>
              } {(DQ (${ Id.VSub_Name KUBE_BUILD_IMAGE))} {(DQ (${ Id.VSub_Name LOCAL_OUTPUT_BUILD_CONTEXT))} 
              {(SQ <false>)}
            )
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                <docker_delete_old_containers>
              } {(DQ (${ Id.VSub_Name KUBE_BUILD_CONTAINER_NAME_BASE))} 
              {(DQ (${ Id.VSub_Name KUBE_BUILD_CONTAINER_NAME))}
            )
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                <docker_delete_old_containers>
              } {(DQ (${ Id.VSub_Name KUBE_RSYNC_CONTAINER_NAME_BASE))} 
              {(DQ (${ Id.VSub_Name KUBE_RSYNC_CONTAINER_NAME))}
            )
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                <docker_delete_old_containers>
              } {(DQ (${ Id.VSub_Name KUBE_DATA_CONTAINER_NAME_BASE))} {(DQ (${ Id.VSub_Name KUBE_DATA_CONTAINER_NAME))}
            )
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                <docker_delete_old_images>
              } {(DQ (${ Id.VSub_Name KUBE_BUILD_IMAGE_REPO))} {(DQ (${ Id.VSub_Name KUBE_BUILD_IMAGE_TAG_BASE))} 
              {(DQ (${ Id.VSub_Name KUBE_BUILD_IMAGE_TAG))}
            )
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                <ensure_data_container>
              }
            )
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                <sync_to_container>
              }
            )
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::docker_build'
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<-r>} {<Id.Lit_VarLike 'image='> ($ Id.VSub_Number '$1')})
            (C {<local>} {<-r>} {<Id.Lit_VarLike 'context_dir='> ($ Id.VSub_Number '$2')})
            (C {<local>} {<-r>} 
              {<Id.Lit_VarLike 'pull='> 
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Number 3>
                    suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:{<true>})
                  )
                )
              }
            )
            (C {<local>} {<-ra>} 
              {<Id.Lit_VarLike 'build_cmd='> 
                (sh_array_literal
                  left: <Id.Op_LParen _>
                  words: [
                    {
                      (DQ 
                        (braced_var_sub
                          token: <Id.VSub_Name DOCKER>
                          bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                        )
                      )
                    }
                    {<build>}
                    {<-t>}
                    {(DQ (${ Id.VSub_Name image))}
                    {(DQ <'--pull='> (${ Id.VSub_Name pull))}
                    {(DQ (${ Id.VSub_Name context_dir))}
                  ]
                )
              }
            )
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                <status>
              } {(DQ <'Building Docker image '> (${ Id.VSub_Name image))}
            )
            (C {<local>} {<docker_output>})
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:docker_output)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (command.Simple
                                words: [
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name build_cmd>
                                        bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                      )
                                    )
                                  }
                                ]
                                redirects: [
                                  (redir
                                    op: <Id.Redir_GreatAnd '2>&'>
                                    loc: (redir_loc.Fd fd:2)
                                    arg: {<1>}
                                  )
                                ]
                                do_fork: T
                              )
                          )
                        }
                      spids: [3922]
                    )
                  ]
                )
                (BraceGroup
                  children: [
                    (command.Simple
                      words: [{<cat>}]
                      redirects: [
                        (redir
                          op: <Id.Redir_DLess '<<'>
                          loc: (redir_loc.Fd fd:0)
                          arg: 
                            (redir_param.HereDoc
                              here_begin: {<EOF>}
                              here_end_span_id: 3972
                              stdin_parts: [
                                <'+++ Docker build command failed for '>
                                (${ Id.VSub_Name image)
                                <'\n'>
                                <'\n'>
                                (${ Id.VSub_Name docker_output)
                                <'\n'>
                                <'\n'>
                                <'To retry manually, run:\n'>
                                <'\n'>
                                (braced_var_sub
                                  token: <Id.VSub_Name build_cmd>
                                  bracket_op: (bracket_op.WholeArray op_id:Id.Arith_Star)
                                )
                                <'\n'>
                                <'\n'>
                              ]
                            )
                        )
                        (redir
                          op: <Id.Redir_GreatAnd '>&'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {<2>}
                        )
                      ]
                      do_fork: T
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<1>}
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::ensure_data_container'
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'ret='> <0>})
            (C {<local>} 
              {<Id.Lit_VarLike 'code='> 
                (command_sub
                  left_token: <Id.Left_DollarParen '$('>
                  child: 
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (command.Simple
                          words: [
                            {<docker>}
                            {<inspect>}
                            {<-f>}
                            {(SQ <'{{.State.ExitCode}}'>)}
                            {(DQ (${ Id.VSub_Name KUBE_DATA_CONTAINER_NAME))}
                          ]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '2>'>
                              loc: (redir_loc.Fd fd:2)
                              arg: {<'/dev/null'>}
                            )
                          ]
                          do_fork: T
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:ret)
                              op: assign_op.Equal
                              rhs: {($ Id.VSub_QMark '$?')}
                              spids: [4042]
                            )
                          ]
                        )
                      ]
                    )
                )
              }
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.LogicalAnd
                                  left: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobDEqual
                                      left: {(DQ (${ Id.VSub_Name ret))}
                                      right: {<0>}
                                    )
                                  right: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobNEqual
                                      left: {(DQ (${ Id.VSub_Name code))}
                                      right: {<0>}
                                    )
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C 
                      {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> 
                        <Id.Lit_Colon ':'> <destroy_container>
                      } {(DQ (${ Id.VSub_Name KUBE_DATA_CONTAINER_NAME))}
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:ret)
                          op: assign_op.Equal
                          rhs: {<1>}
                          spids: [4094]
                        )
                      ]
                    )
                  ]
                  spids: [4047 4076]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobNEqual
                                  left: {(DQ (${ Id.VSub_Name ret))}
                                  right: {<0>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C 
                      {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> 
                        <Id.Lit_Colon ':'> <status>
                      } {(DQ <'Creating data container '> (${ Id.VSub_Name KUBE_DATA_CONTAINER_NAME))}
                    )
                    (C {<mkdir>} {<-p>} {(DQ (${ Id.VSub_Name LOCAL_OUTPUT_GOPATH))})
                    (C {<local>} {<-ra>} 
                      {<Id.Lit_VarLike 'docker_cmd='> 
                        (sh_array_literal
                          left: <Id.Op_LParen _>
                          words: [
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name DOCKER>
                                  bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                )
                              )
                            }
                            {<run>}
                            {<--volume>}
                            {(DQ (${ Id.VSub_Name REMOTE_ROOT))}
                            {<--volume>}
                            {<'/usr/local/go/pkg/linux_386_cgo'>}
                            {<--volume>}
                            {<'/usr/local/go/pkg/linux_amd64_cgo'>}
                            {<--volume>}
                            {<'/usr/local/go/pkg/linux_arm_cgo'>}
                            {<--volume>}
                            {<'/usr/local/go/pkg/linux_arm64_cgo'>}
                            {<--volume>}
                            {<'/usr/local/go/pkg/linux_ppc64le_cgo'>}
                            {<--volume>}
                            {<'/usr/local/go/pkg/darwin_amd64_cgo'>}
                            {<--volume>}
                            {<'/usr/local/go/pkg/darwin_386_cgo'>}
                            {<--volume>}
                            {<'/usr/local/go/pkg/windows_amd64_cgo'>}
                            {<--volume>}
                            {<'/usr/local/go/pkg/windows_386_cgo'>}
                            {<--name>}
                            {(DQ (${ Id.VSub_Name KUBE_DATA_CONTAINER_NAME))}
                            {<--hostname>}
                            {(DQ (${ Id.VSub_Name HOSTNAME))}
                            {(DQ (${ Id.VSub_Name KUBE_BUILD_IMAGE))}
                            {<chown>}
                            {<-R>}
                            {(${ Id.VSub_Name USER_ID) <Id.Lit_Colon ':'> (${ Id.VSub_Name GROUP_ID)}
                            {(DQ (${ Id.VSub_Name REMOTE_ROOT))}
                            {<'/usr/local/go/pkg/'>}
                          ]
                        )
                      }
                    )
                    (C 
                      {
                        (DQ 
                          (braced_var_sub
                            token: <Id.VSub_Name docker_cmd>
                            bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                          )
                        )
                      }
                    )
                  ]
                  spids: [4101 4118]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::run_build_command'
      body: 
        (BraceGroup
          children: [
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                <status>
              } {(DQ <'Running build command...'>)}
            )
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                <run_build_command_ex>
              } {(DQ (${ Id.VSub_Name KUBE_BUILD_CONTAINER_NAME))} {<-->} {(DQ ($ Id.VSub_At '$@'))}
            )
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::run_build_command_ex'
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Binary
                      op_id: Id.BoolBinary_GlobNEqual
                      left: {($ Id.VSub_Pound '$#')}
                      right: {<0>}
                    )
                )
                (BraceGroup
                  children: [
                    (command.Sentence
                      child: 
                        (command.Simple
                          words: [{<echo>} {(DQ <'Invalid input - please specify a container name.'>)}]
                          redirects: [
                            (redir
                              op: <Id.Redir_GreatAnd '>&'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<2>}
                            )
                          ]
                          do_fork: T
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (command.Sentence
                      child: (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<4>})
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              ]
            )
            (C {<local>} {<Id.Lit_VarLike 'container_name='> (DQ (${ Id.VSub_Number 1))})
            (C {<shift>})
            (C {<local>} {<-a>} 
              {<Id.Lit_VarLike 'docker_run_opts='> 
                (sh_array_literal
                  left: <Id.Op_LParen _>
                  words: [
                    {(DQ <'--name='> (${ Id.VSub_Name container_name))}
                    {
                      (DQ <'--user='> 
                        (command_sub
                          left_token: <Id.Left_DollarParen '$('>
                          child: (C {<id>} {<-u>})
                        ) <':'> (command_sub left_token:<Id.Left_DollarParen '$('> child:(C {<id>} {<-g>}))
                      )
                    }
                    {(DQ <'--hostname='> (${ Id.VSub_Name HOSTNAME))}
                    {
                      (DQ 
                        (braced_var_sub
                          token: <Id.VSub_Name DOCKER_MOUNT_ARGS>
                          bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                        )
                      )
                    }
                  ]
                )
              }
            )
            (C {<local>} {<Id.Lit_VarLike 'detach='> <false>})
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Binary
                      op_id: Id.BoolBinary_GlobNEqual
                      left: {($ Id.VSub_Pound '$#')}
                      right: {<0>}
                    )
                )
                (BraceGroup
                  children: [
                    (command.Sentence
                      child: 
                        (command.Simple
                          words: [
                            {<echo>}
                            {(DQ <'Invalid input - please specify docker arguments followed by --.'>)}
                          ]
                          redirects: [
                            (redir
                              op: <Id.Redir_GreatAnd '>&'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<2>}
                            )
                          ]
                          do_fork: T
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (command.Sentence
                      child: (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<4>})
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              ]
            )
            (command.WhileUntil
              keyword: <Id.KW_Until until>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (C {<Id.Lit_LBracket '['>} {<-z>} 
                          {
                            (DQ 
                              (braced_var_sub
                                token: <Id.VSub_Number 1>
                                suffix_op: (suffix_op.Unary tok:<Id.VTest_Hyphen -> arg_word:(word.Empty))
                              )
                            )
                          } {<Id.Lit_RBracket ']'>}
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {(DQ ($ Id.VSub_Number '$1'))}
                                          right: {(DQ <-->)}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<shift>})
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [4581 4598]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:docker_run_opts)
                          op: assign_op.PlusEqual
                          rhs: 
                            {
                              (sh_array_literal
                                left: <Id.Op_LParen _>
                                words: [{(DQ ($ Id.VSub_Number '$1'))}]
                              )
                            }
                          spids: [4610]
                        )
                      ]
                    )
                    (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_GlobDEqual
                                              left: {(DQ ($ Id.VSub_Number '$1'))}
                                              right: {(DQ <-d>)}
                                            )
                                          right: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: {(DQ ($ Id.VSub_Number '$1'))}
                                              right: {(DQ <--detach>)}
                                            )
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:detach)
                                  op: assign_op.Equal
                                  rhs: {<true>}
                                  spids: [4651]
                                )
                              ]
                            )
                          ]
                          spids: [4618 4648]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                )
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Binary
                      op_id: Id.BoolBinary_GlobNEqual
                      left: {($ Id.VSub_Pound '$#')}
                      right: {<0>}
                    )
                )
                (BraceGroup
                  children: [
                    (command.Sentence
                      child: 
                        (command.Simple
                          words: [{<echo>} {(DQ <'Invalid input - please specify a command to run.'>)}]
                          redirects: [
                            (redir
                              op: <Id.Redir_GreatAnd '>&'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<2>}
                            )
                          ]
                          do_fork: T
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (command.Sentence
                      child: (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<4>})
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              ]
            )
            (C {<local>} {<-a>} {<Id.Lit_VarLike 'cmd='> (sh_array_literal left:<Id.Op_LParen _>)})
            (command.WhileUntil
              keyword: <Id.KW_Until until>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (C {<Id.Lit_LBracket '['>} {<-z>} 
                          {
                            (DQ 
                              (braced_var_sub
                                token: <Id.VSub_Number 1>
                                suffix_op: (suffix_op.Unary tok:<Id.VTest_Hyphen -> arg_word:(word.Empty))
                              )
                            )
                          } {<Id.Lit_RBracket ']'>}
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:cmd)
                          op: assign_op.PlusEqual
                          rhs: 
                            {
                              (sh_array_literal
                                left: <Id.Op_LParen _>
                                words: [{(DQ ($ Id.VSub_Number '$1'))}]
                              )
                            }
                          spids: [4730]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:docker_run_opts)
                  op: assign_op.PlusEqual
                  rhs: 
                    {
                      (sh_array_literal
                        left: <Id.Op_LParen _>
                        words: [
                          {<--env>}
                          {
                            (DQ <'KUBE_FASTBUILD='> 
                              (braced_var_sub
                                token: <Id.VSub_Name KUBE_FASTBUILD>
                                suffix_op: 
                                  (suffix_op.Unary
                                    tok: <Id.VTest_ColonHyphen ':-'>
                                    arg_word: {<false>}
                                  )
                              )
                            )
                          }
                          {<--env>}
                          {
                            (DQ <'KUBE_BUILDER_OS='> 
                              (braced_var_sub
                                token: <Id.VSub_Name OSTYPE>
                                suffix_op: 
                                  (suffix_op.Unary
                                    tok: <Id.VTest_ColonHyphen ':-'>
                                    arg_word: {<notdetected>}
                                  )
                              )
                            )
                          }
                          {<--env>}
                          {(DQ <'KUBE_VERBOSE='> (${ Id.VSub_Name KUBE_VERBOSE))}
                          {<--env>}
                          {
                            (DQ <'GOFLAGS='> 
                              (braced_var_sub
                                token: <Id.VSub_Name GOFLAGS>
                                suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:(word.Empty))
                              )
                            )
                          }
                          {<--env>}
                          {
                            (DQ <'GOLDFLAGS='> 
                              (braced_var_sub
                                token: <Id.VSub_Name GOLDFLAGS>
                                suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:(word.Empty))
                              )
                            )
                          }
                          {<--env>}
                          {
                            (DQ <'GOGCFLAGS='> 
                              (braced_var_sub
                                token: <Id.VSub_Name GOGCFLAGS>
                                suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:(word.Empty))
                              )
                            )
                          }
                        ]
                      )
                    }
                  spids: [4745]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: (bool_expr.Unary op_id:Id.BoolUnary_t child:{<0>})
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:docker_run_opts)
                          op: assign_op.PlusEqual
                          rhs: 
                            {
                              (sh_array_literal
                                left: <Id.Op_LParen _>
                                words: [{<--interactive>} {<--tty>}]
                              )
                            }
                          spids: [4850]
                        )
                      ]
                    )
                  ]
                  spids: [4836 4847]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {(DQ (${ Id.VSub_Name detach))}
                                  right: {<false>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:docker_run_opts)
                          op: assign_op.PlusEqual
                          rhs: 
                            {
                              (sh_array_literal
                                left: <Id.Op_LParen _>
                                words: [
                                  {<--attach> <Id.Lit_Equals '='> <stdout>}
                                  {<--attach> <Id.Lit_Equals '='> <stderr>}
                                ]
                              )
                            }
                          spids: [4878]
                        )
                      ]
                    )
                  ]
                  spids: [4858 4875]
                )
              ]
            )
            (C {<local>} {<-ra>} 
              {<Id.Lit_VarLike 'docker_cmd='> 
                (sh_array_literal
                  left: <Id.Op_LParen _>
                  words: [
                    {
                      (DQ 
                        (braced_var_sub
                          token: <Id.VSub_Name DOCKER>
                          bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                        )
                      )
                    }
                    {<run>}
                    {
                      (DQ 
                        (braced_var_sub
                          token: <Id.VSub_Name docker_run_opts>
                          bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                        )
                      )
                    }
                    {(DQ (${ Id.VSub_Name KUBE_BUILD_IMAGE))}
                  ]
                )
              }
            )
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                <destroy_container>
              } {(DQ (${ Id.VSub_Name container_name))}
            )
            (C 
              {
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name docker_cmd>
                    bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                  )
                )
              } {(DQ (braced_var_sub token:<Id.VSub_Name cmd> bracket_op:(bracket_op.WholeArray op_id:Id.Lit_At)))}
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {(DQ (${ Id.VSub_Name detach))}
                                  right: {<false>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C 
                      {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> 
                        <Id.Lit_Colon ':'> <destroy_container>
                      } {(DQ (${ Id.VSub_Name container_name))}
                    )
                  ]
                  spids: [4969 4986]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::rsync_probe'
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'tries='> <20>})
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (command.DParen
                          child: 
                            (arith_expr.Binary
                              op_id: Id.Arith_Great
                              left: {(${ Id.VSub_Name tries)}
                              right: {<Id.Lit_Digits 0>}
                            )
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.Simple
                                      words: [
                                        {<rsync>}
                                        {
                                          (DQ <'rsync://k8s@'> (${ Id.VSub_Number 1) <':'> 
                                            (${ Id.VSub_Number 2) <'/'>
                                          )
                                        }
                                        {<--password-file> <Id.Lit_Equals '='> 
                                          (DQ (${ Id.VSub_Name LOCAL_OUTPUT_BUILD_CONTEXT) 
                                            <'/rsyncd.password'>
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (redir
                                          op: <Id.Redir_AndGreat '&>'>
                                          loc: (redir_loc.Fd fd:1)
                                          arg: {<'/dev/null'>}
                                        )
                                      ]
                                      do_fork: T
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                              arg_word: {<0>}
                            )
                          ]
                          spids: [5052 5087]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:tries)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (word_part.ArithSub
                                anode: 
                                  (arith_expr.Binary
                                    op_id: Id.Arith_Minus
                                    left: {(${ Id.VSub_Name tries)}
                                    right: {<Id.Lit_Digits 1>}
                                  )
                              )
                            }
                          spids: [5098]
                        )
                      ]
                    )
                    (C {<sleep>} {<0.1>})
                  ]
                )
            )
            (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<1>})
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::start_rsyncd_container'
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:IPTOOL)
                  op: assign_op.Equal
                  rhs: {<ifconfig>}
                  spids: [5158]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C 
                              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> 
                                <Id.Lit_Colon ':'> <has_ip>
                              }
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:IPTOOL)
                          op: assign_op.Equal
                          rhs: {(DQ <'ip address'>)}
                          spids: [5177]
                        )
                      ]
                    )
                  ]
                  spids: [5162 5174]
                )
              ]
            )
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                <stop_rsyncd_container>
              }
            )
            (command.Simple
              words: [
                {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                  <status>
                }
                {(DQ <'Starting rsyncd container'>)}
              ]
              more_env: [(env_pair name:V val:{<3>} spids:[5195])]
              do_fork: T
            )
            (command.Simple
              words: [
                {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> 
                  <Id.Lit_Colon ':'> <run_build_command_ex>
                }
                {(DQ (${ Id.VSub_Name KUBE_RSYNC_CONTAINER_NAME))}
                {<-p>}
                {<127.0.0.1> <Id.Lit_Colon ':'> (${ Id.VSub_Name KUBE_RSYNC_PORT) <Id.Lit_Colon ':'> 
                  (${ Id.VSub_Name KUBE_CONTAINER_RSYNC_PORT)
                }
                {<-d>}
                {<-e>}
                {<Id.Lit_VarLike 'ALLOW_HOST='> 
                  (DQ 
                    (command_sub
                      left_token: <Id.Left_DollarParen '$('>
                      child: 
                        (command.Pipeline
                          children: [
                            (C {(${ Id.VSub_Name IPTOOL)})
                            (C {<grep>} {<-Eo>} {(SQ <'inet (addr:)?([0-9]*\\.){3}[0-9]*'>)})
                            (C {<grep>} {<-Eo>} {(SQ <'([0-9]*\\.){3}[0-9]*'>)})
                            (C {<grep>} {<-v>} {(SQ <127.0.0.1>)})
                          ]
                          negated: F
                        )
                    )
                  )
                }
                {<-->}
                {<'/rsyncd.sh'>}
              ]
              redirects: [(redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<'/dev/null'>})]
              do_fork: T
            )
            (C {<local>} {<mapped_port>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.Pipeline
                              children: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:mapped_port)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: 
                                              (command.Pipeline
                                                children: [
                                                  (command.Simple
                                                    words: [
                                                      {
                                                        (DQ 
                                                          (braced_var_sub
                                                            token: <Id.VSub_Name DOCKER>
                                                            bracket_op: 
                                                              (bracket_op.WholeArray
                                                                op_id: Id.Lit_At
                                                              )
                                                          )
                                                        )
                                                      }
                                                      {<port>}
                                                      {
                                                        (DQ 
                                                          (${ Id.VSub_Name KUBE_RSYNC_CONTAINER_NAME)
                                                        )
                                                      }
                                                      {(${ Id.VSub_Name KUBE_CONTAINER_RSYNC_PORT)}
                                                    ]
                                                    redirects: [
                                                      (redir
                                                        op: <Id.Redir_Great '2>'>
                                                        loc: (redir_loc.Fd fd:2)
                                                        arg: {<'/dev/null'>}
                                                      )
                                                    ]
                                                    do_fork: T
                                                  )
                                                  (C {<cut>} {<-d> <Id.Lit_Colon ':'>} {<-f>} {<2>})
                                                ]
                                                negated: F
                                              )
                                          )
                                        }
                                      spids: [5304]
                                    )
                                  ]
                                )
                              ]
                              negated: T
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C 
                      {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> 
                        <Id.Lit_Colon ':'> <error>
                      } {(DQ <'Could not get effective rsync port'>)}
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<1>}
                    )
                  ]
                  spids: [5300 5345]
                )
              ]
            )
            (C {<local>} {<container_ip>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:container_ip)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (C 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name DOCKER>
                                  bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                )
                              )
                            } {<inspect>} {<--format>} {(SQ <'{{ .NetworkSettings.IPAddress }}'>)} 
                            {(DQ (${ Id.VSub_Name KUBE_RSYNC_CONTAINER_NAME))}
                          )
                      )
                    }
                  spids: [5375]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C 
                              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> 
                                <Id.Lit_Colon ':'> <rsync_probe>
                              } {<127.0.0.1>} {(${ Id.VSub_Name mapped_port)}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:KUBE_RSYNC_ADDR)
                          op: assign_op.Equal
                          rhs: {(DQ <'127.0.0.1:'> (${ Id.VSub_Name mapped_port))}
                          spids: [5443]
                        )
                      ]
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [5423 5440]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C 
                              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> 
                                <Id.Lit_Colon ':'> <rsync_probe>
                              } {(DQ (${ Id.VSub_Name container_ip))} {(${ Id.VSub_Name KUBE_CONTAINER_RSYNC_PORT)}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:KUBE_RSYNC_ADDR)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ (${ Id.VSub_Name container_ip) <':'> 
                                (${ Id.VSub_Name KUBE_CONTAINER_RSYNC_PORT)
                              )
                            }
                          spids: [5481]
                        )
                      ]
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [5457 5478]
                )
              ]
            )
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                <error>
              } 
              {
                (DQ 
                  <
'Could not connect to rsync container. See build/README.md for setting up remote Docker engine.'
                  >
                )
              }
            )
            (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<1>})
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::stop_rsyncd_container'
      body: 
        (BraceGroup
          children: [
            (command.Simple
              words: [
                {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                  <status>
                }
                {(DQ <'Stopping any currently running rsyncd container'>)}
              ]
              more_env: [(env_pair name:V val:{<3>} spids:[5537])]
              do_fork: T
            )
            (C {<unset>} {<KUBE_RSYNC_ADDR>})
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                <destroy_container>
              } {(DQ (${ Id.VSub_Name KUBE_RSYNC_CONTAINER_NAME))}
            )
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::rsync'
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<-a>} 
              {<Id.Lit_VarLike 'rsync_opts='> 
                (sh_array_literal
                  left: <Id.Op_LParen _>
                  words: [
                    {<--archive>}
                    {<--password-file> <Id.Lit_Equals '='> 
                      (DQ (${ Id.VSub_Name LOCAL_OUTPUT_BUILD_CONTEXT) <'/rsyncd.password'>)
                    }
                  ]
                )
              }
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DParen
                              child: 
                                (arith_expr.Binary
                                  op_id: Id.Arith_GreatEqual
                                  left: {(${ Id.VSub_Name KUBE_VERBOSE)}
                                  right: {<Id.Lit_Digits 6>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:rsync_opts)
                          op: assign_op.PlusEqual
                          rhs: {(sh_array_literal left:<Id.Op_LParen _> words:[{(DQ <-iv>)}])}
                          spids: [5631]
                        )
                      ]
                    )
                  ]
                  spids: [5612 5628]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DParen
                              child: 
                                (arith_expr.Binary
                                  op_id: Id.Arith_Great
                                  left: {(${ Id.VSub_Name KUBE_RSYNC_COMPRESS)}
                                  right: {<Id.Lit_Digits 0>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:rsync_opts)
                          op: assign_op.PlusEqual
                          rhs: 
                            {
                              (sh_array_literal
                                left: <Id.Op_LParen _>
                                words: [
                                  {(DQ <'--compress-level='> (${ Id.VSub_Name KUBE_RSYNC_COMPRESS))}
                                ]
                              )
                            }
                          spids: [5661]
                        )
                      ]
                    )
                  ]
                  spids: [5642 5658]
                )
              ]
            )
            (command.Simple
              words: [
                {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                  <status>
                }
                {(DQ <'Running rsync'>)}
              ]
              more_env: [(env_pair name:V val:{<3>} spids:[5675])]
              do_fork: T
            )
            (C {<rsync>} 
              {
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name rsync_opts>
                    bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                  )
                )
              } {(DQ ($ Id.VSub_At '$@'))}
            )
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::sync_to_container'
      body: 
        (BraceGroup
          children: [
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                <status>
              } {(DQ <'Syncing sources to container'>)}
            )
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                <start_rsyncd_container>
              }
            )
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                <rsync>
              } {<--delete>} {<--filter> <Id.Lit_Equals '='> (SQ <'H /.git/'>)} 
              {<--filter> <Id.Lit_Equals '='> (SQ <'- /.make/'>)} {<--filter> <Id.Lit_Equals '='> (SQ <'- /_tmp/'>)} {<--filter> <Id.Lit_Equals '='> (SQ <'- /_output/'>)} 
              {<--filter> <Id.Lit_Equals '='> (SQ <'- /'>)} {<--filter> <Id.Lit_Equals '='> (SQ <'H zz_generated.*'>)} 
              {<--filter> <Id.Lit_Equals '='> (SQ <'H generated.proto'>)} {(DQ (${ Id.VSub_Name KUBE_ROOT) <'/'>)} 
              {(DQ <'rsync://k8s@'> (${ Id.VSub_Name KUBE_RSYNC_ADDR) <'/k8s/'>)}
            )
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                <stop_rsyncd_container>
              }
            )
          ]
        )
    )
    (command.ShFunction
      name: 'kube::build::copy_output'
      body: 
        (BraceGroup
          children: [
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <log> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                <status>
              } {(DQ <'Syncing out of container'>)}
            )
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                <start_rsyncd_container>
              }
            )
            (C {<local>} {<Id.Lit_VarLike 'rsync_extra='> (DQ )})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DParen
                              child: 
                                (arith_expr.Binary
                                  op_id: Id.Arith_GreatEqual
                                  left: {(${ Id.VSub_Name KUBE_VERBOSE)}
                                  right: {<Id.Lit_Digits 6>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:rsync_extra)
                          op: assign_op.Equal
                          rhs: {(DQ <-iv>)}
                          spids: [5956]
                        )
                      ]
                    )
                  ]
                  spids: [5937 5953]
                )
              ]
            )
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                <rsync>
              } {<--prune-empty-dirs>} {<--filter> <Id.Lit_Equals '='> (SQ <'- /_temp/'>)} 
              {<--filter> <Id.Lit_Equals '='> (SQ <'+ /vendor/'>)} {<--filter> <Id.Lit_Equals '='> (SQ <'+ /Godeps/'>)} 
              {<--filter> <Id.Lit_Equals '='> (SQ <'+ /staging/***/Godeps/**'>)} {<--filter> <Id.Lit_Equals '='> (SQ <'+ /_output/dockerized/bin/**'>)} 
              {<--filter> <Id.Lit_Equals '='> (SQ <'+ zz_generated.*'>)} {<--filter> <Id.Lit_Equals '='> (SQ <'+ generated.proto'>)} 
              {<--filter> <Id.Lit_Equals '='> (SQ <'+ *.pb.go'>)} {<--filter> <Id.Lit_Equals '='> (SQ <'+ types.go'>)} {<--filter> <Id.Lit_Equals '='> (SQ <'+ */'>)} 
              {<--filter> <Id.Lit_Equals '='> (SQ <'- /**'>)} {(DQ <'rsync://k8s@'> (${ Id.VSub_Name KUBE_RSYNC_ADDR) <'/k8s/'>)} {(DQ (${ Id.VSub_Name KUBE_ROOT))}
            )
            (C 
              {<kube> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> <build> <Id.Lit_Colon ':'> <Id.Lit_Colon ':'> 
                <stop_rsyncd_container>
              }
            )
          ]
        )
    )
  ]
)