# Maintainer: Natanael Copa <ncopa@alpinelinux.org>
global pkgname := 'docker'
global pkgver := '17.07.0'
global _ver := "$(pkgver/_/-)-ce"
global pkgrel := '0'
global _gitcommit := "v$_ver"
global pkgdesc := '"Pack, ship and run any application as a lightweight container'"
global url := '"http://www.docker.io/'"
global arch := '"all !s390x'"
global license := '"ASL 2.0'"
global depends := '"ca-certificates iptables'"
global depends_dev := ''""
global makedepends := '"go btrfs-progs-dev bash linux-headers coreutils libseccomp-dev cmake lvm2-dev glide libtool'"
global options := '"!check'"
global install := ""$pkgname.pre-install""

# $ grep COMMIT hack/dockerfile/binaries-commits
# TOMLV_COMMIT=9baf8a8a9f2ed20a8e54160840c492f937eeaf9a
# RUNC_COMMIT=2d41c047c83e09a6d61d464906feb2a2f3c52aa4
# CONTAINERD_COMMIT=3addd840653146c90a254301d6c3a663c7fd6429
# TINI_COMMIT=949e6facb77383876aeff8a6944dde66b3089574
# LIBNETWORK_COMMIT=7b2b1feb1de4817d522cc372af149ff48d25028e
# VNDR_COMMIT=9909bb2b8a0b7ea464527b376dc50389c90df587

global _runc_ver := '2d41c047c83e09a6d61d464906feb2a2f3c52aa4'
global _containerd_ver := '3addd840653146c90a254301d6c3a663c7fd6429'
global _libnetwork_ver := '7b2b1feb1de4817d522cc372af149ff48d25028e'
global _tini_ver := '949e6facb77383876aeff8a6944dde66b3089574'

global subpackages := ""
	$pkgname-bash-completion:bashcomp:noarch
	$pkgname-fish-completion:fishcomp:noarch
	$pkgname-zsh-completion:zshcomp:noarch
	$pkgname-vim:vim:noarch
	$pkgname-doc
	""
global source := ""
	docker-$pkgver.tar.gz::https://github.com/docker/docker-ce/archive/v$_ver.tar.gz
	runc-$_runc_ver.tar.gz::https://github.com/docker/runc/archive/$_runc_ver.tar.gz
	containerd-$_containerd_ver.tar.gz::https://github.com/docker/containerd/archive/$_containerd_ver.tar.gz
	libnetwork-$_libnetwork_ver.tar.gz::https://github.com/docker/libnetwork/archive/$_libnetwork_ver.tar.gz
	tini-$_tini_ver.tar.gz::https://github.com/krallin/tini/archive/$_tini_ver.tar.gz
	go-md2man.tar.gz::https://github.com/cpuguy83/go-md2man/archive/master.tar.gz
	cobra.tar.gz::https://github.com/spf13/cobra/archive/master.tar.gz
	docker-openrc-fixes.patch
	tini-cmake-fixes.patch
	docker-openrc-busybox-ash.patch
	""

global _dockerdir := ""$srcdir"/docker-$_ver"
global _cli_builddir := ""$_dockerdir"/components/cli"
global _daemon_builddir := ""$_dockerdir"/components/engine"
#_buildtags="exclude_graphdriver_aufs exclude_graphdriver_devicemapper"
global _buildtags := ''""
global _runc_buildtags := '"seccomp'"
global _runc_builddir := ""$srcdir"/runc-$_runc_ver"

global _containerd_builddir := ""$srcdir"/containerd-$_containerd_ver"
global _libnetwork_builddir := ""$srcdir"/libnetwork-$_libnetwork_ver"
global _tini_builddir := ""$srcdir"/tini-$_tini_ver"

proc _apply_patches {
	var _dir = $1
	var _prefix = $2
	var i = ''
	msg "applying patches for $_prefix"
	cd $_dir
	for i in [$source] {
		matchstr $i {
		${_prefix}-*.patch { msg $i; patch -p1 -i "$srcdir"/$i || return 1}
		}
	}
}

proc prepare {
	# Rename 'docker-ce-VER' to 'docker-VER'
	mv "$srcdir"/docker-ce-$_ver $_dockerdir

	_apply_patches $_daemon_builddir docker || return 1
	_apply_patches $_runc_builddir runc || return 1
	_apply_patches $_tini_builddir tini || return 1
}

proc build {
	export AUTO_GOPATH=1
	#export GOPATH="$srcdir"
	#export GOBIN="$GOPATH"/bin
	#export PATH="$GOBIN:$PATH"
	export DOCKER_GITCOMMIT=$_gitcommit
	export DOCKER_BUILDTAGS=$_buildtags
	unset CC # prevent possible ccache issues

	# containerd
	msg "building containerd"
	cd $_containerd_builddir || return 1
	mkdir -p src/github.com/containerd/
	ln -s $_containerd_builddir src/github.com/containerd/containerd
	env GOPATH=$PWD LDFLAGS="" make GIT_COMMIT="$_containerd_ver" || return 1

	# libnetwork (docker-proxy)
	msg "building docker-proxy"
	cd $_libnetwork_builddir || return 1
	mkdir -p src/github.com/docker/
	ln -s $_libnetwork_builddir src/github.com/docker/libnetwork
	env GOPATH=$PWD go build -v -ldflags="-linkmode=external" -o docker-proxy github.com/docker/libnetwork/cmd/proxy || return 1

	# runc
	msg "building runc"
	cd $_runc_builddir || return 1
	mkdir -p src/github.com/opencontainers/
	ln -s $_runc_builddir src/github.com/opencontainers/runc
	cd src/github.com/opencontainers/runc
	env GOPATH=$PWD make COMMIT="$_runc_ver" || return 1

	# tini
	msg "building tini"
	cd $_tini_builddir || return 1
	cmake -DVERSION_GIT=$_tini_ver || return 1
	make tini-static|| return 1

	# daemon
	msg "building daemon"
	cd $_daemon_builddir || return 1
	mkdir -p src/github.com/docker/
	ln -s $_daemon_builddir src/github.com/docker/docker
	env GOPATH=$PWD VERSION=$_ver hack/make.sh dynbinary

	# Required for building man-pages
	export GOPATH="$_cli_builddir"
	export GOBIN="$GOPATH/bin"
	export PATH="$GOBIN:$PATH"

	# cli
	msg "building cli"
	cd $_cli_builddir || return 1
	mkdir -p "$GOPATH"/src/github.com/docker/
	ln -s $_cli_builddir "$GOPATH"/src/github.com/docker/cli
	env LDFLAGS="" make VERSION="$_ver" dynbinary || return 1

	# docker man
	msg "building docker man pages"
	cd $srcdir || return 1
	# cobra
	mkdir -p "$GOPATH"/src/github.com/spf13/
	ln -sf "$PWD"/cobra-master "$GOPATH"/src/github.com/spf13/cobra
	# md2man
	mkdir -p "$GOPATH"/src/github.com/cpuguy83/
	ln -s "$PWD"/go-md2man-master "$GOPATH"/src/github.com/cpuguy83/go-md2man
	cd "$GOPATH"/src/github.com/cpuguy83/go-md2man || return 1
	go get

	# convert md to man pages
	msg "generating man pages"
	cd $_cli_builddir || return 1
	make manpages
}

proc package {
	cd $_dockerdir
	var ver = $[cat VERSION]

	# 'build/docker' is a symlink to 'docker-linux-$arch' e.g. 'docker-linux-amd64'
	install -Dm755 "$_cli_builddir"/build/docker \
		"$pkgdir"/usr/bin/docker || return 1

	install -Dm755 "$_daemon_builddir"/bundles/$ver/dynbinary-daemon/dockerd-$ver \
		"$pkgdir"/usr/bin/dockerd || return 1

	install -Dm755 "$_libnetwork_builddir"/docker-proxy \
		"$pkgdir"/usr/bin/docker-proxy || return 1

	install -Dm755 "$_runc_builddir"/runc \
		"$pkgdir"/usr/bin/docker-runc || return 1

	install -Dm755 "$_containerd_builddir"/bin/containerd \
		"$pkgdir"/usr/bin/docker-containerd || return 1

	install -Dm755 "$_containerd_builddir"/bin/containerd-shim \
		"$pkgdir"/usr/bin/docker-containerd-shim || return 1

	install -Dm755 "$_containerd_builddir"/bin/ctr \
		"$pkgdir"/usr/bin/docker-containerd-ctr || return 1

	install -Dm755 "$_tini_builddir"/tini-static \
		"$pkgdir"/usr/bin/docker-init || return 1

	install -Dm755 "$_daemon_builddir"/contrib/init/openrc/docker.initd \
		"$pkgdir"/etc/init.d/docker || return 1
	install -Dm644 "$_daemon_builddir"/contrib/init/openrc/docker.confd \
		"$pkgdir"/etc/conf.d/docker || return 1

	mkdir -p "$pkgdir"/usr/share/man/man1
	install -Dm644 "$_cli_builddir"/man/man1/* \
		"$pkgdir"/usr/share/man/man1 || return 1
}

proc bashcomp {
	global pkgdesc := '"Bash completion for Docker'"
	global depends := ''""
	global install_if := ""$pkgname=$pkgver-r$pkgrel bash-completion""

	install -Dm644 "$_cli_builddir"/contrib/completion/bash/$pkgname \
		"$subpkgdir"/usr/share/bash-completion/completions/$pkgname
}

proc fishcomp {
	global pkgdesc := '"Fish shell completion for Docker'"
	global depends := ''""
	global install_if := ""$pkgname=$pkgver-r$pkgrel fish""

	install -Dm644 "$_cli_builddir"/contrib/completion/fish/$pkgname.fish \
		"$subpkgdir"/usr/share/fish/completions/$pkgname.fish || return 1
}

proc zshcomp {
	global pkgdesc := ""Zsh completion for $pkgname""
	global depends := ''""
	global install_if := ""$pkgname=$pkgver-r$pkgrel zsh""

	install -Dm644 "$_cli_builddir"/contrib/completion/zsh/_$pkgname \
		"$subpkgdir"/usr/share/zsh/site-functions/_$pkgname || return 1
}

proc vim {
	global depends := ''""
	global pkgdesc := '"Vim syntax for Docker'"

	var f = ''
	for f in [ftdetect/dockerfile.vim syntax/dockerfile.vim] {
		install -Dm644 "$_daemon_builddir"/contrib/syntax/vim/$f \
			"$subpkgdir"/usr/share/vim/vimfiles/$f
	}
}

global sha512sums := '"c34164983021e7de9872510f739446f372444147e336e928b1b4d7bd87876440ec2358206bf0fcc231ead03c0171a8bde0b897f044d9bd696ac5f1cf203fc9db  docker-17.07.0.tar.gz
4c86946a8200db67b3c914dd5e52e64e27d417b1fd2fdecd57d12de76798d554ed05acd761b58020d262fda2f98f15e45385ae621666952b1d82a28f7dd7918a  runc-2d41c047c83e09a6d61d464906feb2a2f3c52aa4.tar.gz
cc8cdfbac5b2ea671d96a9016d53a510bd2d7854d9d8cdd551929568a47eaaed044f2ae1152acf83a487aa2f7df8b61ffb00de3d4f837d93eee383d96929ace4  containerd-3addd840653146c90a254301d6c3a663c7fd6429.tar.gz
673ea638fa5c560d8238d7c1d88f114430f9d8efe701804bfe30044d0c059a688cbf6b62922be50834e16ee055ef6cf015f6232f76f0d942768f9e84e95496cd  libnetwork-7b2b1feb1de4817d522cc372af149ff48d25028e.tar.gz
b6c1454f734662adf2fdedcb75cb7cdc82f4cf5b4c41fadf6891a670fa26d49b789034f4af8bf920b9e1ff1c3536123637ade9471f4ae2c1ef6c534e839b9f27  tini-949e6facb77383876aeff8a6944dde66b3089574.tar.gz
4fe8c193b1d1f64d9fce656842d47a9beba672b947c29e2f2ae50a7d13a13b8ac5c22ed2a4c76c4df3cc384282b79496067f27046800ebbb2c957c00a7eaed9a  go-md2man.tar.gz
31b71f60505c6442a9b048a8346c6a990cf334774e6c9172181a8123ab513ac37bfef01d86cc866a0dec8ba97d61ed064a3b3f4a15b23715b9a7d81a1395ef80  cobra.tar.gz
8296b1bc88ef3dec4f9038c4e0bf83120ac5870860f6662eac9f9f8850ea8b7596bcd2b47932551e804ae8b6f6f26ad3bc4ce6d49600cc8eaf0a3016c15a9ccf  docker-openrc-fixes.patch
29a343848d0aa14864c6bfc87c2a6fd408f546f0114e12f7035fb4678ee769fe728872a5d283803177990a61d7e02c4916017d5e45380ad3b0a2dffa3e746857  tini-cmake-fixes.patch
9b24dc0c50904c3d12bb04c1a7df169651043ddbc258018647010a5aa01d8a19ad54d10ca79dce6d6283c81f4fa0cc8de417f6180dd824c5a588b22b23546cb5  docker-openrc-busybox-ash.patch'"
(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:pkgname) op:Equal rhs:{(docker)} spids:[3])]
      spids: [3]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:pkgver) op:Equal rhs:{(17.07.0)} spids:[6])]
      spids: [6]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_ver)
          op: Equal
          rhs: 
            {
              (BracedVarSub
                token: <VSub_Name pkgver>
                suffix_op: 
                  (PatSub
                    pat: {(_)}
                    replace: {(-)}
                    do_all: False
                    do_prefix: False
                    do_suffix: False
                  )
                spids: [10 16]
              ) (-ce)
            }
          spids: [9]
        )
      ]
      spids: [9]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:pkgrel) op:Equal rhs:{(0)} spids:[19])]
      spids: [19]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_gitcommit)
          op: Equal
          rhs: {(v) ($ VSub_Name "$_ver")}
          spids: [22]
        )
      ]
      spids: [22]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:pkgdesc)
          op: Equal
          rhs: {(DQ ("Pack, ship and run any application as a lightweight container"))}
          spids: [26]
        )
      ]
      spids: [26]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:url)
          op: Equal
          rhs: {(DQ ("http://www.docker.io/"))}
          spids: [31]
        )
      ]
      spids: [31]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:arch) op:Equal rhs:{(DQ ("all !s390x"))} spids:[36])]
      spids: [36]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:license) op:Equal rhs:{(DQ ("ASL 2.0"))} spids:[41])]
      spids: [41]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:depends)
          op: Equal
          rhs: {(DQ ("ca-certificates iptables"))}
          spids: [46]
        )
      ]
      spids: [46]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:depends_dev) op:Equal rhs:{(DQ )} spids:[51])]
      spids: [51]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:makedepends)
          op: Equal
          rhs: 
            {
              (DQ 
                (
"go btrfs-progs-dev bash linux-headers coreutils libseccomp-dev cmake lvm2-dev glide libtool"
                )
              )
            }
          spids: [55]
        )
      ]
      spids: [55]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:options) op:Equal rhs:{(DQ ("!check"))} spids:[60])]
      spids: [60]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:install)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$pkgname") (.pre-install))}
          spids: [65]
        )
      ]
      spids: [65]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_runc_ver)
          op: Equal
          rhs: {(2d41c047c83e09a6d61d464906feb2a2f3c52aa4)}
          spids: [94]
        )
      ]
      spids: [94]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_containerd_ver)
          op: Equal
          rhs: {(3addd840653146c90a254301d6c3a663c7fd6429)}
          spids: [97]
        )
      ]
      spids: [97]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_libnetwork_ver)
          op: Equal
          rhs: {(7b2b1feb1de4817d522cc372af149ff48d25028e)}
          spids: [100]
        )
      ]
      spids: [100]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_tini_ver)
          op: Equal
          rhs: {(949e6facb77383876aeff8a6944dde66b3089574)}
          spids: [103]
        )
      ]
      spids: [103]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:subpackages)
          op: Equal
          rhs: 
            {
              (DQ ("\n") ("\t") ($ VSub_Name "$pkgname") ("-bash-completion:bashcomp:noarch\n") ("\t") 
                ($ VSub_Name "$pkgname") ("-fish-completion:fishcomp:noarch\n") ("\t") ($ VSub_Name "$pkgname") 
                ("-zsh-completion:zshcomp:noarch\n") ("\t") ($ VSub_Name "$pkgname") ("-vim:vim:noarch\n") ("\t") ($ VSub_Name "$pkgname") ("-doc\n") ("\t")
              )
            }
          spids: [107]
        )
      ]
      spids: [107]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:source)
          op: Equal
          rhs: 
            {
              (DQ ("\n") ("\tdocker-") ($ VSub_Name "$pkgver") 
                (".tar.gz::https://github.com/docker/docker-ce/archive/v") ($ VSub_Name "$_ver") (".tar.gz\n") ("\trunc-") ($ VSub_Name "$_runc_ver") 
                (".tar.gz::https://github.com/docker/runc/archive/") ($ VSub_Name "$_runc_ver") (".tar.gz\n") ("\tcontainerd-") ($ VSub_Name "$_containerd_ver") 
                (".tar.gz::https://github.com/docker/containerd/archive/") ($ VSub_Name "$_containerd_ver") (".tar.gz\n") ("\tlibnetwork-") ($ VSub_Name "$_libnetwork_ver") 
                (".tar.gz::https://github.com/docker/libnetwork/archive/") ($ VSub_Name "$_libnetwork_ver") (".tar.gz\n") ("\ttini-") ($ VSub_Name "$_tini_ver") 
                (".tar.gz::https://github.com/krallin/tini/archive/") ($ VSub_Name "$_tini_ver") (".tar.gz\n") 
                (
"\tgo-md2man.tar.gz::https://github.com/cpuguy83/go-md2man/archive/master.tar.gz\n"
                ) ("\tcobra.tar.gz::https://github.com/spf13/cobra/archive/master.tar.gz\n") 
                ("\tdocker-openrc-fixes.patch\n") ("\ttini-cmake-fixes.patch\n") ("\tdocker-openrc-busybox-ash.patch\n") ("\t")
              )
            }
          spids: [128]
        )
      ]
      spids: [128]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_dockerdir)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$srcdir")) (/docker-) ($ VSub_Name "$_ver")}
          spids: [165]
        )
      ]
      spids: [165]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_cli_builddir)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$_dockerdir")) (/components/cli)}
          spids: [172]
        )
      ]
      spids: [172]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_daemon_builddir)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$_dockerdir")) (/components/engine)}
          spids: [178]
        )
      ]
      spids: [178]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:_buildtags) op:Equal rhs:{(DQ )} spids:[187])]
      spids: [187]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_runc_buildtags)
          op: Equal
          rhs: {(DQ (seccomp))}
          spids: [191]
        )
      ]
      spids: [191]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_runc_builddir)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$srcdir")) (/runc-) ($ VSub_Name "$_runc_ver")}
          spids: [196]
        )
      ]
      spids: [196]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_containerd_builddir)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$srcdir")) (/containerd-) ($ VSub_Name "$_containerd_ver")}
          spids: [204]
        )
      ]
      spids: [204]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_libnetwork_builddir)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$srcdir")) (/libnetwork-) ($ VSub_Name "$_libnetwork_ver")}
          spids: [211]
        )
      ]
      spids: [211]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_tini_builddir)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$srcdir")) (/tini-) ($ VSub_Name "$_tini_ver")}
          spids: [218]
        )
      ]
      spids: [218]
    )
    (FuncDef
      name: _apply_patches
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:_dir)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [235]
                )
              ]
              spids: [233]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:_prefix)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$2"))}
                  spids: [243]
                )
              ]
              spids: [241]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [(assign_pair lhs:(LhsName name:i) op:Equal spids:[251])]
              spids: [249]
            )
            (C {(msg)} {(DQ ("applying patches for ") ($ VSub_Name "$_prefix"))})
            (C {(cd)} {(DQ ($ VSub_Name "$_dir"))})
            (ForEach
              iter_name: i
              iter_words: [{($ VSub_Name "$source")}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (Case
                      to_match: {($ VSub_Name "$i")}
                      arms: [
                        (case_arm
                          pat_list: [{(${ VSub_Name _prefix) (-) (Lit_Other "*") (.patch)}]
                          action: [
                            (Sentence
                              child: (C {(msg)} {($ VSub_Name "$i")})
                              terminator: <Op_Semi ";">
                            )
                            (AndOr
                              children: [
                                (C {(patch)} {(-p1)} {(-i)} 
                                  {(DQ ($ VSub_Name "$srcdir")) (/) ($ VSub_Name "$i")}
                                )
                                (ControlFlow
                                  token: <ControlFlow_Return return>
                                  arg_word: {(1)}
                                )
                              ]
                              op_id: Op_DPipe
                            )
                          ]
                          spids: [288 294 318 -1]
                        )
                      ]
                      spids: [281 285 321]
                    )
                  ]
                  spids: [278 324]
                )
              spids: [274 276]
            )
          ]
          spids: [230]
        )
      spids: [226 229]
    )
    (FuncDef
      name: prepare
      body: 
        (BraceGroup
          children: [
            (C {(mv)} {(DQ ($ VSub_Name "$srcdir")) (/docker-ce-) ($ VSub_Name "$_ver")} 
              {(DQ ($ VSub_Name "$_dockerdir"))}
            )
            (AndOr
              children: [
                (C {(_apply_patches)} {(DQ ($ VSub_Name "$_daemon_builddir"))} {(docker)})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (AndOr
              children: [
                (C {(_apply_patches)} {(DQ ($ VSub_Name "$_runc_builddir"))} {(runc)})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (AndOr
              children: [
                (C {(_apply_patches)} {(DQ ($ VSub_Name "$_tini_builddir"))} {(tini)})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [333]
        )
      spids: [329 332]
    )
    (FuncDef
      name: build
      body: 
        (BraceGroup
          children: [
            (C {(export)} {(Lit_VarLike "AUTO_GOPATH=") (1)})
            (C {(export)} {(Lit_VarLike "DOCKER_GITCOMMIT=") ($ VSub_Name "$_gitcommit")})
            (C {(export)} {(Lit_VarLike "DOCKER_BUILDTAGS=") ($ VSub_Name "$_buildtags")})
            (C {(unset)} {(CC)})
            (C {(msg)} {(DQ ("building containerd"))})
            (AndOr
              children: [
                (C {(cd)} {(DQ ($ VSub_Name "$_containerd_builddir"))})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (C {(mkdir)} {(-p)} {(src/github.com/containerd/)})
            (C {(ln)} {(-s)} {(DQ ($ VSub_Name "$_containerd_builddir"))} 
              {(src/github.com/containerd/containerd)}
            )
            (AndOr
              children: [
                (SimpleCommand
                  words: [{(make)} {(Lit_VarLike "GIT_COMMIT=") (DQ ($ VSub_Name "$_containerd_ver"))}]
                  more_env: [
                    (env_pair
                      name: GOPATH
                      val: {(DQ ($ VSub_Name "$PWD"))}
                      spids: [489]
                    )
                    (env_pair name:LDFLAGS val:{(DQ )} spids:[494])
                  ]
                )
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (C {(msg)} {(DQ ("building docker-proxy"))})
            (AndOr
              children: [
                (C {(cd)} {(DQ ($ VSub_Name "$_libnetwork_builddir"))})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (C {(mkdir)} {(-p)} {(src/github.com/docker/)})
            (C {(ln)} {(-s)} {(DQ ($ VSub_Name "$_libnetwork_builddir"))} 
              {(src/github.com/docker/libnetwork)}
            )
            (AndOr
              children: [
                (SimpleCommand
                  words: [
                    {(go)}
                    {(build)}
                    {(-v)}
                    {(-ldflags) (Lit_Other "=") (DQ ("-linkmode=external"))}
                    {(-o)}
                    {(docker-proxy)}
                    {(github.com/docker/libnetwork/cmd/proxy)}
                  ]
                  more_env: [(env_pair name:GOPATH val:{(DQ ($ VSub_Name "$PWD"))} spids:[555])]
                )
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (C {(msg)} {(DQ ("building runc"))})
            (AndOr
              children: [
                (C {(cd)} {(DQ ($ VSub_Name "$_runc_builddir"))})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (C {(mkdir)} {(-p)} {(src/github.com/opencontainers/)})
            (C {(ln)} {(-s)} {(DQ ($ VSub_Name "$_runc_builddir"))} 
              {(src/github.com/opencontainers/runc)}
            )
            (C {(cd)} {(src/github.com/opencontainers/runc)})
            (AndOr
              children: [
                (SimpleCommand
                  words: [{(make)} {(Lit_VarLike "COMMIT=") (DQ ($ VSub_Name "$_runc_ver"))}]
                  more_env: [(env_pair name:GOPATH val:{(DQ ($ VSub_Name "$PWD"))} spids:[633])]
                )
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (C {(msg)} {(DQ ("building tini"))})
            (AndOr
              children: [
                (C {(cd)} {(DQ ($ VSub_Name "$_tini_builddir"))})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (AndOr
              children: [
                (C {(cmake)} {(-DVERSION_GIT) (Lit_Other "=") ($ VSub_Name "$_tini_ver")})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (AndOr
              children: [
                (C {(make)} {(tini-static)})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (C {(msg)} {(DQ ("building daemon"))})
            (AndOr
              children: [
                (C {(cd)} {(DQ ($ VSub_Name "$_daemon_builddir"))})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (C {(mkdir)} {(-p)} {(src/github.com/docker/)})
            (C {(ln)} {(-s)} {(DQ ($ VSub_Name "$_daemon_builddir"))} {(src/github.com/docker/docker)})
            (SimpleCommand
              words: [{(hack/make.sh)} {(dynbinary)}]
              more_env: [
                (env_pair name:GOPATH val:{(DQ ($ VSub_Name "$PWD"))} spids:[743])
                (env_pair name:VERSION val:{(DQ ($ VSub_Name "$_ver"))} spids:[748])
              ]
            )
            (C {(export)} {(Lit_VarLike "GOPATH=") (DQ ($ VSub_Name "$_cli_builddir"))})
            (C {(export)} {(Lit_VarLike "GOBIN=") (DQ ($ VSub_Name "$GOPATH") (/bin))})
            (C {(export)} 
              {(Lit_VarLike "PATH=") (DQ ($ VSub_Name "$GOBIN") (":") ($ VSub_Name "$PATH"))}
            )
            (C {(msg)} {(DQ ("building cli"))})
            (AndOr
              children: [
                (C {(cd)} {(DQ ($ VSub_Name "$_cli_builddir"))})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$GOPATH")) (/src/github.com/docker/)})
            (C {(ln)} {(-s)} {(DQ ($ VSub_Name "$_cli_builddir"))} 
              {(DQ ($ VSub_Name "$GOPATH")) (/src/github.com/docker/cli)}
            )
            (AndOr
              children: [
                (SimpleCommand
                  words: [{(make)} {(Lit_VarLike "VERSION=") (DQ ($ VSub_Name "$_ver"))} {(dynbinary)}]
                  more_env: [(env_pair name:LDFLAGS val:{(DQ )} spids:[839])]
                )
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (C {(msg)} {(DQ ("building docker man pages"))})
            (AndOr
              children: [
                (C {(cd)} {(DQ ($ VSub_Name "$srcdir"))})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$GOPATH")) (/src/github.com/spf13/)})
            (C {(ln)} {(-sf)} {(DQ ($ VSub_Name "$PWD")) (/cobra-master)} 
              {(DQ ($ VSub_Name "$GOPATH")) (/src/github.com/spf13/cobra)}
            )
            (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$GOPATH")) (/src/github.com/cpuguy83/)})
            (C {(ln)} {(-s)} {(DQ ($ VSub_Name "$PWD")) (/go-md2man-master)} 
              {(DQ ($ VSub_Name "$GOPATH")) (/src/github.com/cpuguy83/go-md2man)}
            )
            (AndOr
              children: [
                (C {(cd)} {(DQ ($ VSub_Name "$GOPATH")) (/src/github.com/cpuguy83/go-md2man)})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (C {(go)} {(get)})
            (C {(msg)} {(DQ ("generating man pages"))})
            (AndOr
              children: [
                (C {(cd)} {(DQ ($ VSub_Name "$_cli_builddir"))})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (C {(make)} {(manpages)})
          ]
          spids: [405]
        )
      spids: [401 404]
    )
    (FuncDef
      name: package
      body: 
        (BraceGroup
          children: [
            (C {(cd)} {(DQ ($ VSub_Name "$_dockerdir"))})
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:ver)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: (CommandList children:[(C {(cat)} {(VERSION)})])
                        left_token: <Left_CommandSub "$(">
                        spids: [1010 1014]
                      )
                    }
                  spids: [1009]
                )
              ]
              spids: [1007]
            )
            (AndOr
              children: [
                (C {(install)} {(-Dm755)} {(DQ ($ VSub_Name "$_cli_builddir")) (/build/docker)} 
                  {(DQ ($ VSub_Name "$pkgdir")) (/usr/bin/docker)}
                )
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (AndOr
              children: [
                (C {(install)} {(-Dm755)} 
                  {(DQ ($ VSub_Name "$_daemon_builddir")) (/bundles/) ($ VSub_Name "$ver") 
                    (/dynbinary-daemon/dockerd-) ($ VSub_Name "$ver")
                  } {(DQ ($ VSub_Name "$pkgdir")) (/usr/bin/dockerd)}
                )
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (AndOr
              children: [
                (C {(install)} {(-Dm755)} {(DQ ($ VSub_Name "$_libnetwork_builddir")) (/docker-proxy)} 
                  {(DQ ($ VSub_Name "$pkgdir")) (/usr/bin/docker-proxy)}
                )
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (AndOr
              children: [
                (C {(install)} {(-Dm755)} {(DQ ($ VSub_Name "$_runc_builddir")) (/runc)} 
                  {(DQ ($ VSub_Name "$pkgdir")) (/usr/bin/docker-runc)}
                )
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (AndOr
              children: [
                (C {(install)} {(-Dm755)} {(DQ ($ VSub_Name "$_containerd_builddir")) (/bin/containerd)} 
                  {(DQ ($ VSub_Name "$pkgdir")) (/usr/bin/docker-containerd)}
                )
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (AndOr
              children: [
                (C {(install)} {(-Dm755)} 
                  {(DQ ($ VSub_Name "$_containerd_builddir")) (/bin/containerd-shim)} {(DQ ($ VSub_Name "$pkgdir")) (/usr/bin/docker-containerd-shim)}
                )
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (AndOr
              children: [
                (C {(install)} {(-Dm755)} {(DQ ($ VSub_Name "$_containerd_builddir")) (/bin/ctr)} 
                  {(DQ ($ VSub_Name "$pkgdir")) (/usr/bin/docker-containerd-ctr)}
                )
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (AndOr
              children: [
                (C {(install)} {(-Dm755)} {(DQ ($ VSub_Name "$_tini_builddir")) (/tini-static)} 
                  {(DQ ($ VSub_Name "$pkgdir")) (/usr/bin/docker-init)}
                )
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (AndOr
              children: [
                (C {(install)} {(-Dm755)} 
                  {(DQ ($ VSub_Name "$_daemon_builddir")) (/contrib/init/openrc/docker.initd)} {(DQ ($ VSub_Name "$pkgdir")) (/etc/init.d/docker)}
                )
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (AndOr
              children: [
                (C {(install)} {(-Dm644)} 
                  {(DQ ($ VSub_Name "$_daemon_builddir")) (/contrib/init/openrc/docker.confd)} {(DQ ($ VSub_Name "$pkgdir")) (/etc/conf.d/docker)}
                )
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$pkgdir")) (/usr/share/man/man1)})
            (AndOr
              children: [
                (C {(install)} {(-Dm644)} 
                  {(DQ ($ VSub_Name "$_cli_builddir")) (/man/man1/) (Lit_Other "*")} {(DQ ($ VSub_Name "$pkgdir")) (/usr/share/man/man1)}
                )
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [997]
        )
      spids: [993 996]
    )
    (FuncDef
      name: bashcomp
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:pkgdesc)
                  op: Equal
                  rhs: {(DQ ("Bash completion for Docker"))}
                  spids: [1307]
                )
              ]
              spids: [1307]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:depends) op:Equal rhs:{(DQ )} spids:[1313])]
              spids: [1313]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:install_if)
                  op: Equal
                  rhs: 
                    {
                      (DQ ($ VSub_Name "$pkgname") ("=") ($ VSub_Name "$pkgver") (-r) 
                        ($ VSub_Name "$pkgrel") (" bash-completion")
                      )
                    }
                  spids: [1318]
                )
              ]
              spids: [1318]
            )
            (C {(install)} {(-Dm644)} 
              {(DQ ($ VSub_Name "$_cli_builddir")) (/contrib/completion/bash/) 
                ($ VSub_Name "$pkgname")
              } {(DQ ($ VSub_Name "$subpkgdir")) (/usr/share/bash-completion/completions/) ($ VSub_Name "$pkgname")}
            )
          ]
          spids: [1304]
        )
      spids: [1300 1303]
    )
    (FuncDef
      name: fishcomp
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:pkgdesc)
                  op: Equal
                  rhs: {(DQ ("Fish shell completion for Docker"))}
                  spids: [1358]
                )
              ]
              spids: [1358]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:depends) op:Equal rhs:{(DQ )} spids:[1364])]
              spids: [1364]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:install_if)
                  op: Equal
                  rhs: 
                    {
                      (DQ ($ VSub_Name "$pkgname") ("=") ($ VSub_Name "$pkgver") (-r) 
                        ($ VSub_Name "$pkgrel") (" fish")
                      )
                    }
                  spids: [1369]
                )
              ]
              spids: [1369]
            )
            (AndOr
              children: [
                (C {(install)} {(-Dm644)} 
                  {(DQ ($ VSub_Name "$_cli_builddir")) (/contrib/completion/fish/) 
                    ($ VSub_Name "$pkgname") (.fish)
                  } {(DQ ($ VSub_Name "$subpkgdir")) (/usr/share/fish/completions/) ($ VSub_Name "$pkgname") (.fish)}
                )
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [1355]
        )
      spids: [1351 1354]
    )
    (FuncDef
      name: zshcomp
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:pkgdesc)
                  op: Equal
                  rhs: {(DQ ("Zsh completion for ") ($ VSub_Name "$pkgname"))}
                  spids: [1417]
                )
              ]
              spids: [1417]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:depends) op:Equal rhs:{(DQ )} spids:[1424])]
              spids: [1424]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:install_if)
                  op: Equal
                  rhs: 
                    {
                      (DQ ($ VSub_Name "$pkgname") ("=") ($ VSub_Name "$pkgver") (-r) 
                        ($ VSub_Name "$pkgrel") (" zsh")
                      )
                    }
                  spids: [1429]
                )
              ]
              spids: [1429]
            )
            (AndOr
              children: [
                (C {(install)} {(-Dm644)} 
                  {(DQ ($ VSub_Name "$_cli_builddir")) (/contrib/completion/zsh/_) 
                    ($ VSub_Name "$pkgname")
                  } {(DQ ($ VSub_Name "$subpkgdir")) (/usr/share/zsh/site-functions/_) ($ VSub_Name "$pkgname")}
                )
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [1414]
        )
      spids: [1410 1413]
    )
    (FuncDef
      name: vim
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:depends) op:Equal rhs:{(DQ )} spids:[1475])]
              spids: [1475]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:pkgdesc)
                  op: Equal
                  rhs: {(DQ ("Vim syntax for Docker"))}
                  spids: [1480]
                )
              ]
              spids: [1480]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [(assign_pair lhs:(LhsName name:f) op:Equal rhs:{(SQ )} spids:[1489])]
              spids: [1487]
            )
            (ForEach
              iter_name: f
              iter_words: [{(ftdetect/dockerfile.vim)} {(syntax/dockerfile.vim)}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (C {(install)} {(-Dm644)} 
                      {(DQ ($ VSub_Name "$_daemon_builddir")) (/contrib/syntax/vim/) 
                        ($ VSub_Name "$f")
                      } {(DQ ($ VSub_Name "$subpkgdir")) (/usr/share/vim/vimfiles/) ($ VSub_Name "$f")}
                    )
                  ]
                  spids: [1503 1525]
                )
              spids: [1497 1501]
            )
          ]
          spids: [1472]
        )
      spids: [1468 1471]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:sha512sums)
          op: Equal
          rhs: 
            {
              (DQ 
                (
"c34164983021e7de9872510f739446f372444147e336e928b1b4d7bd87876440ec2358206bf0fcc231ead03c0171a8bde0b897f044d9bd696ac5f1cf203fc9db  docker-17.07.0.tar.gz\n"
                ) 
                (
"4c86946a8200db67b3c914dd5e52e64e27d417b1fd2fdecd57d12de76798d554ed05acd761b58020d262fda2f98f15e45385ae621666952b1d82a28f7dd7918a  runc-2d41c047c83e09a6d61d464906feb2a2f3c52aa4.tar.gz\n"
                ) 
                (
"cc8cdfbac5b2ea671d96a9016d53a510bd2d7854d9d8cdd551929568a47eaaed044f2ae1152acf83a487aa2f7df8b61ffb00de3d4f837d93eee383d96929ace4  containerd-3addd840653146c90a254301d6c3a663c7fd6429.tar.gz\n"
                ) 
                (
"673ea638fa5c560d8238d7c1d88f114430f9d8efe701804bfe30044d0c059a688cbf6b62922be50834e16ee055ef6cf015f6232f76f0d942768f9e84e95496cd  libnetwork-7b2b1feb1de4817d522cc372af149ff48d25028e.tar.gz\n"
                ) 
                (
"b6c1454f734662adf2fdedcb75cb7cdc82f4cf5b4c41fadf6891a670fa26d49b789034f4af8bf920b9e1ff1c3536123637ade9471f4ae2c1ef6c534e839b9f27  tini-949e6facb77383876aeff8a6944dde66b3089574.tar.gz\n"
                ) 
                (
"4fe8c193b1d1f64d9fce656842d47a9beba672b947c29e2f2ae50a7d13a13b8ac5c22ed2a4c76c4df3cc384282b79496067f27046800ebbb2c957c00a7eaed9a  go-md2man.tar.gz\n"
                ) 
                (
"31b71f60505c6442a9b048a8346c6a990cf334774e6c9172181a8123ab513ac37bfef01d86cc866a0dec8ba97d61ed064a3b3f4a15b23715b9a7d81a1395ef80  cobra.tar.gz\n"
                ) 
                (
"8296b1bc88ef3dec4f9038c4e0bf83120ac5870860f6662eac9f9f8850ea8b7596bcd2b47932551e804ae8b6f6f26ad3bc4ce6d49600cc8eaf0a3016c15a9ccf  docker-openrc-fixes.patch\n"
                ) 
                (
"29a343848d0aa14864c6bfc87c2a6fd408f546f0114e12f7035fb4678ee769fe728872a5d283803177990a61d7e02c4916017d5e45380ad3b0a2dffa3e746857  tini-cmake-fixes.patch\n"
                ) 
                (
"9b24dc0c50904c3d12bb04c1a7df169651043ddbc258018647010a5aa01d8a19ad54d10ca79dce6d6283c81f4fa0cc8de417f6180dd824c5a588b22b23546cb5  docker-openrc-busybox-ash.patch"
                )
              )
            }
          spids: [1530]
        )
      ]
      spids: [1530]
    )
  ]
)