(command.CommandList
  children: [
    (C {<set>} {<-e>})
    (C {<set>} {<-x>})
    (C {<.>} 
      {
        (command_sub
          left_token: <Id.Left_DollarParen '$('>
          child: (C {<dirname>} {(DQ ($ Id.VSub_Number '$0'))})
        ) <'/binaries-commits'>
      }
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:RM_GOPATH)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [24]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:TMP_GOPATH)
          op: assign_op.Equal
          rhs: 
            {
              (braced_var_sub
                token: <Id.VSub_Name TMP_GOPATH>
                suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:{(DQ )})
              )
            }
          spids: [28]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ ($ Id.VSub_DollarName '$TMP_GOPATH'))} 
                      {<Id.Lit_RBracket ']'>}
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (C {<export>} 
              {<Id.Lit_VarLike 'GOPATH='> 
                (DQ (command_sub left_token:<Id.Left_DollarParen '$('> child:(C {<mktemp>} {<-d>})))
              }
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:RM_GOPATH)
                  op: assign_op.Equal
                  rhs: {<1>}
                  spids: [65]
                )
              ]
            )
          ]
          spids: [37 50]
        )
      ]
      else_action: [
        (C {<export>} {<Id.Lit_VarLike 'GOPATH='> (DQ ($ Id.VSub_DollarName '$TMP_GOPATH'))})
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:RUNC_BUILDTAGS)
          op: assign_op.Equal
          rhs: 
            {
              (DQ 
                (braced_var_sub
                  token: <Id.VSub_Name RUNC_BUILDTAGS>
                  suffix_op: 
                    (suffix_op.Unary
                      tok: <Id.VTest_ColonHyphen ':-'>
                      arg_word: {(DQ <'seccomp apparmor selinux'>)}
                    )
                )
              )
            }
          spids: [84]
        )
      ]
    )
    (command.ShFunction
      name: install_runc
      body: 
        (BraceGroup
          children: [
            (C {<echo>} {(DQ <'Install runc version '> ($ Id.VSub_DollarName '$RUNC_COMMIT'))})
            (C {<git>} {<clone>} {<https> <Id.Lit_Colon ':'> <'//github.com/opencontainers/runc.git'>} 
              {(DQ ($ Id.VSub_DollarName '$GOPATH') <'/src/github.com/opencontainers/runc'>)}
            )
            (C {<cd>} {(DQ ($ Id.VSub_DollarName '$GOPATH') <'/src/github.com/opencontainers/runc'>)})
            (C {<git>} {<checkout>} {<-q>} {(DQ ($ Id.VSub_DollarName '$RUNC_COMMIT'))})
            (C {<make>} {<Id.Lit_VarLike 'BUILDTAGS='> (DQ ($ Id.VSub_DollarName '$RUNC_BUILDTAGS'))} 
              {($ Id.VSub_Number '$1')}
            )
            (C {<cp>} {<runc>} {<'/usr/local/bin/docker-runc'>})
          ]
        )
    )
    (command.ShFunction
      name: install_containerd
      body: 
        (BraceGroup
          children: [
            (C {<echo>} 
              {(DQ <'Install containerd version '> ($ Id.VSub_DollarName '$CONTAINERD_COMMIT'))}
            )
            (C {<git>} {<clone>} {<https> <Id.Lit_Colon ':'> <'//github.com/containerd/containerd.git'>} 
              {(DQ ($ Id.VSub_DollarName '$GOPATH') <'/src/github.com/containerd/containerd'>)}
            )
            (C {<cd>} {(DQ ($ Id.VSub_DollarName '$GOPATH') <'/src/github.com/containerd/containerd'>)})
            (C {<git>} {<checkout>} {<-q>} {(DQ ($ Id.VSub_DollarName '$CONTAINERD_COMMIT'))})
            (C {<make>} {($ Id.VSub_Number '$1')})
            (C {<cp>} {<'bin/containerd'>} {<'/usr/local/bin/docker-containerd'>})
            (C {<cp>} {<'bin/containerd-shim'>} {<'/usr/local/bin/docker-containerd-shim'>})
            (C {<cp>} {<'bin/ctr'>} {<'/usr/local/bin/docker-containerd-ctr'>})
          ]
        )
    )
    (command.ShFunction
      name: install_proxy
      body: 
        (BraceGroup
          children: [
            (C {<echo>} 
              {(DQ <'Install docker-proxy version '> ($ Id.VSub_DollarName '$LIBNETWORK_COMMIT'))}
            )
            (C {<git>} {<clone>} {<https> <Id.Lit_Colon ':'> <'//github.com/docker/libnetwork.git'>} 
              {(DQ ($ Id.VSub_DollarName '$GOPATH') <'/src/github.com/docker/libnetwork'>)}
            )
            (C {<cd>} {(DQ ($ Id.VSub_DollarName '$GOPATH') <'/src/github.com/docker/libnetwork'>)})
            (C {<git>} {<checkout>} {<-q>} {(DQ ($ Id.VSub_DollarName '$LIBNETWORK_COMMIT'))})
            (C {<go>} {<build>} 
              {<-ldflags> <Id.Lit_Equals '='> (DQ ($ Id.VSub_DollarName '$PROXY_LDFLAGS'))} {<-o>} {<'/usr/local/bin/docker-proxy'>} {<'github.com/docker/libnetwork/cmd/proxy'>}
            )
          ]
        )
    )
    (command.ShFunction
      name: install_dockercli
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:DOCKERCLI_CHANNEL)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <Id.VSub_Name DOCKERCLI_CHANNEL>
                        suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:{<edge>})
                      )
                    }
                  spids: [313]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:DOCKERCLI_VERSION)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <Id.VSub_Name DOCKERCLI_VERSION>
                        suffix_op: 
                          (suffix_op.Unary
                            tok: <Id.VTest_ColonHyphen ':-'>
                            arg_word: {<17.06.0-ce>}
                          )
                      )
                    }
                  spids: [321]
                )
              ]
            )
            (C {<echo>} 
              {
                (DQ <'Install docker/cli version '> ($ Id.VSub_DollarName '$DOCKERCLI_VERSION') 
                  <' from '> ($ Id.VSub_DollarName '$DOCKERCLI_CHANNEL')
                )
              }
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:arch)
                  op: assign_op.Equal
                  rhs: {(command_sub left_token:<Id.Left_DollarParen '$('> child:(C {<uname>} {<-m>}))}
                  spids: [340]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobNEqual
                                      left: {(DQ ($ Id.VSub_DollarName '$arch'))}
                                      right: {(DQ <x86_64>)}
                                    )
                                )
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobNEqual
                                      left: {(DQ ($ Id.VSub_DollarName '$arch'))}
                                      right: {(DQ <s390x>)}
                                    )
                                )
                              ]
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<build_dockercli>})
                    (command.ControlFlow token:<Id.ControlFlow_Return return>)
                  ]
                  spids: [352 385]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:url)
                  op: assign_op.Equal
                  rhs: {<https> <Id.Lit_Colon ':'> <'//download.docker.com/linux/static'>}
                  spids: [398]
                )
              ]
            )
            (command.Pipeline
              children: [
                (C {<curl>} {<-Ls>} 
                  {($ Id.VSub_DollarName '$url') <'/'> ($ Id.VSub_DollarName '$DOCKERCLI_CHANNEL') 
                    <'/'> ($ Id.VSub_DollarName '$arch') <'/docker-'> ($ Id.VSub_DollarName '$DOCKERCLI_VERSION') <.tgz>
                  }
                )
                (C {<tar>} {<-xz>} {<'docker/docker'>})
              ]
              negated: F
            )
            (C {<mv>} {<'docker/docker'>} {<'/usr/local/bin/'>})
            (C {<rmdir>} {<docker>})
          ]
        )
    )
    (command.ShFunction
      name: build_dockercli
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:DOCKERCLI_VERSION)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <Id.VSub_Name DOCKERCLI_VERSION>
                        suffix_op: 
                          (suffix_op.Unary
                            tok: <Id.VTest_ColonHyphen ':-'>
                            arg_word: {<17.06.0-ce>}
                          )
                      )
                    }
                  spids: [449]
                )
              ]
            )
            (C {<git>} {<clone>} {<https> <Id.Lit_Colon ':'> <'//github.com/docker/docker-ce'>} 
              {(DQ ($ Id.VSub_DollarName '$GOPATH') <'/tmp/docker-ce'>)}
            )
            (C {<cd>} {(DQ ($ Id.VSub_DollarName '$GOPATH') <'/tmp/docker-ce'>)})
            (C {<git>} {<checkout>} {<-q>} {(DQ <v> ($ Id.VSub_DollarName '$DOCKERCLI_VERSION'))})
            (C {<mkdir>} {<-p>} {(DQ ($ Id.VSub_DollarName '$GOPATH') <'/src/github.com/docker'>)})
            (C {<mv>} {<'components/cli'>} 
              {(DQ ($ Id.VSub_DollarName '$GOPATH') <'/src/github.com/docker/cli'>)}
            )
            (C {<go>} {<build>} {<-o>} {<'/usr/local/bin/docker'>} {<'github.com/docker/cli/cmd/docker'>})
          ]
        )
    )
    (command.ShFunction
      name: install_gometalinter
      body: 
        (BraceGroup
          children: [
            (C {<echo>} 
              {
                (DQ <'Installing gometalinter version '> ($ Id.VSub_DollarName '$GOMETALINTER_COMMIT'))
              }
            )
            (C {<go>} {<get>} {<-d>} {<'github.com/alecthomas/gometalinter'>})
            (C {<cd>} 
              {(DQ ($ Id.VSub_DollarName '$GOPATH') <'/src/github.com/alecthomas/gometalinter'>)}
            )
            (C {<git>} {<checkout>} {<-q>} {(DQ ($ Id.VSub_DollarName '$GOMETALINTER_COMMIT'))})
            (C {<go>} {<build>} {<-o>} {<'/usr/local/bin/gometalinter'>} 
              {<'github.com/alecthomas/gometalinter'>}
            )
            (command.Simple
              words: [{<gometalinter>} {<--install>}]
              more_env: [(env_pair name:GOBIN val:{<'/usr/local/bin'>} spids:[578])]
              do_fork: T
            )
          ]
        )
    )
    (command.ForEach
      iter_name: prog
      iter_words: [{(DQ ($ Id.VSub_At '$@'))}]
      do_arg_iter: F
      body: 
        (command.DoGroup
          children: [
            (command.Case
              to_match: {($ Id.VSub_DollarName '$prog')}
              arms: [
                (case_arm
                  pat_list: [{<tomlv>}]
                  action: [
                    (C {<echo>} {(DQ <'Install tomlv version '> ($ Id.VSub_DollarName '$TOMLV_COMMIT'))})
                    (C {<git>} {<clone>} 
                      {<https> <Id.Lit_Colon ':'> <'//github.com/BurntSushi/toml.git'>} {(DQ ($ Id.VSub_DollarName '$GOPATH') <'/src/github.com/BurntSushi/toml'>)}
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<cd>} 
                          {(DQ ($ Id.VSub_DollarName '$GOPATH') <'/src/github.com/BurntSushi/toml'>)}
                        )
                        (C {<git>} {<checkout>} {<-q>} {(DQ ($ Id.VSub_DollarName '$TOMLV_COMMIT'))})
                      ]
                    )
                    (C {<go>} {<build>} {<-v>} {<-o>} {<'/usr/local/bin/tomlv'>} 
                      {<'github.com/BurntSushi/toml/cmd/tomlv'>}
                    )
                  ]
                  spids: [608 609 667 -1]
                )
                (case_arm
                  pat_list: [{<runc>}]
                  action: [(C {<install_runc>} {<static>})]
                  spids: [671 672 680 -1]
                )
                (case_arm
                  pat_list: [{<runc-dynamic>}]
                  action: [(C {<install_runc>})]
                  spids: [684 685 691 -1]
                )
                (case_arm
                  pat_list: [{<containerd>}]
                  action: [(C {<install_containerd>} {<static>})]
                  spids: [695 696 704 -1]
                )
                (case_arm
                  pat_list: [{<containerd-dynamic>}]
                  action: [(C {<install_containerd>})]
                  spids: [708 709 715 -1]
                )
                (case_arm
                  pat_list: [{<gometalinter>}]
                  action: [(C {<install_gometalinter>})]
                  spids: [719 720 726 -1]
                )
                (case_arm
                  pat_list: [{<tini>}]
                  action: [
                    (C {<echo>} {(DQ <'Install tini version '> ($ Id.VSub_DollarName '$TINI_COMMIT'))})
                    (C {<git>} {<clone>} {<https> <Id.Lit_Colon ':'> <'//github.com/krallin/tini.git'>} 
                      {(DQ ($ Id.VSub_DollarName '$GOPATH') <'/tini'>)}
                    )
                    (C {<cd>} {(DQ ($ Id.VSub_DollarName '$GOPATH') <'/tini'>)})
                    (C {<git>} {<checkout>} {<-q>} {(DQ ($ Id.VSub_DollarName '$TINI_COMMIT'))})
                    (C {<cmake>} {<.>})
                    (C {<make>} {<tini-static>})
                    (C {<cp>} {<tini-static>} {<'/usr/local/bin/docker-init'>})
                  ]
                  spids: [730 731 792 -1]
                )
                (case_arm
                  pat_list: [{<proxy>}]
                  action: [
                    (command.Subshell
                      child: 
                        (command.CommandList
                          children: [
                            (C {<export>} {<Id.Lit_VarLike 'CGO_ENABLED='> <0>})
                            (C {<install_proxy>})
                          ]
                        )
                    )
                  ]
                  spids: [796 797 815 -1]
                )
                (case_arm
                  pat_list: [{<proxy-dynamic>}]
                  action: [
                    (command.Simple
                      words: [{<install_proxy>}]
                      more_env: [
                        (env_pair
                          name: PROXY_LDFLAGS
                          val: {(DQ <'-linkmode=external'>)}
                          spids: [823]
                        )
                      ]
                      do_fork: T
                    )
                  ]
                  spids: [819 820 831 -1]
                )
                (case_arm
                  pat_list: [{<vndr>}]
                  action: [
                    (C {<echo>} {(DQ <'Install vndr version '> ($ Id.VSub_DollarName '$VNDR_COMMIT'))})
                    (C {<git>} {<clone>} {<https> <Id.Lit_Colon ':'> <'//github.com/LK4D4/vndr.git'>} 
                      {(DQ ($ Id.VSub_DollarName '$GOPATH') <'/src/github.com/LK4D4/vndr'>)}
                    )
                    (C {<cd>} {(DQ ($ Id.VSub_DollarName '$GOPATH') <'/src/github.com/LK4D4/vndr'>)})
                    (C {<git>} {<checkout>} {<-q>} {(DQ ($ Id.VSub_DollarName '$VNDR_COMMIT'))})
                    (C {<go>} {<build>} {<-v>} {<-o>} {<'/usr/local/bin/vndr'>} {<.>})
                  ]
                  spids: [835 836 893 -1]
                )
                (case_arm
                  pat_list: [{<dockercli>}]
                  action: [(C {<install_dockercli>})]
                  spids: [897 898 904 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (C {<echo>} {<echo>} 
                      {
                        (DQ <'Usage: '> ($ Id.VSub_Number '$0') 
                          <
' [tomlv|runc|runc-dynamic|containerd|containerd-dynamic|tini|proxy|proxy-dynamic|vndr|dockercli|gometalinter]'
                          >
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Exit exit>
                      arg_word: {<1>}
                    )
                  ]
                  spids: [908 909 -1 929]
                )
              ]
            )
          ]
        )
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (C {<Id.Lit_LBracket '['>} {($ Id.VSub_DollarName '$RM_GOPATH')} {<-eq>} {<1>} 
                      {<Id.Lit_RBracket ']'>}
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [(C {<rm>} {<-rf>} {(DQ ($ Id.VSub_DollarName '$GOPATH'))})]
          spids: [934 947]
        )
      ]
    )
  ]
)